home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume33 / archie / part01 < prev    next >
Encoding:
Text File  |  1992-11-10  |  54.7 KB  |  2,001 lines
  1. Newsgroups: comp.sources.misc
  2. From: brendan@cygnus.com (Brendan Kehoe)
  3. Subject:  v33i050:  archie - A client to query the Archie FTP databases, v1.4.1, Part01/07
  4. Message-ID: <csm-v33i050=archie.145604@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: f72fa1a60a8684951e575c05203ad538
  6. Date: Thu, 5 Nov 1992 20:59:05 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: brendan@cygnus.com (Brendan Kehoe)
  10. Posting-number: Volume 33, Issue 50
  11. Archive-name: archie/part01
  12. Environment: UNIX, VMS, DOS
  13. Supersedes: archie: Volume 27, Issue 79-84
  14.  
  15. [ Version 1.4.1 ]
  16.  
  17.  Enclosed you'll find a Prospero client for the archie service.  It'll
  18. let you query the archie databases without actually using an
  19. interactive process on the remote server's machine (e.g., archie.ans.net),
  20. resulting in a MUCH better response time.  It also helps lessen the
  21. load on the archie server itself.
  22.  
  23.  What's Archie?  It's a system that will let you check a database containing
  24. thousands of entries for the files that're available at FTP sites around
  25. the world.
  26.  
  27.  This is a third child of Clifford Neuman's Prospero project.  It's really
  28. the Archie client that's included in the prospero stuff, but I've taken out
  29. everything that's unnecessary for this client to work.  (Aka, you don't
  30. have to build all of Prospero to get the Archie client.)  Khun Yee Fung
  31. wrote an archie client in Perl, George Ferguson has written a client
  32. for use with XWindows, based in part upon this code.  Also, Scott
  33. Stark wrote a NeXT-Step client for the NeXT.
  34.  
  35.  Also included in this release is a GNU Emacs Lisp front-end to the
  36. archie client.  Note that it requires the Ange FTP package to work
  37. properly.  You can retrieve it from archive.cis.ohio-state.edu in the
  38. directory /pub/gnu/emacs/elisp-archive/packages as ange-ftp.tar.Z.
  39.  
  40.  Using the Archie Prospero interface in its true form will probably be of
  41. interest---check out the file `Prospero' for an example of its interface.
  42. If you find it intriguing, you should probably get the full prospero kit
  43. from the University of Washington on cs.washington.edu in pub/prospero.tar.Z.
  44.  
  45.  Suffice to say, there are now a number of ways to query Archie without
  46. bogging a server down with your logins.
  47.  
  48.  Check out the man page (or archie.doc, if you're using VMS or DOS)
  49. for instructions on how to use this archie client.  VMS users please
  50. note that you have to put quotes around args that are capital letters;
  51. for example,  `$ ARCHIE "-L"'  to list the available servers.
  52.  
  53.  Please check to make sure you don't have "archie" aliased or modified
  54. in some way to do a telnet or rlogin (which you may've done before
  55. this command-line ability came into being).
  56.  
  57.  If Archie consistently hangs (at different times of day with
  58. different queries), it's possible that your site has UDP traffic on
  59. ports > 1000 blocked, for security reasons.  Contact your local
  60. system administrator.
  61.  
  62.  Write to archie-group@cc.mcgill.ca with questions about Archie itself.
  63.  Write to info-prospero@isi.edu about the Prospero protocol.
  64.  Write to brendan@cygnus.com with questions about this specific package.
  65. -----------
  66. #! /bin/sh
  67. # This is a shell archive.  Remove anything before this line, then feed it
  68. # into a shell via "sh file" or similar.  To overwrite existing files,
  69. # type "sh file -c".
  70. # Contents:  README README.ALEX README.dos msdos vms vms/in.h
  71. #   vms_support.c
  72. # Wrapped by kent@sparky on Thu Nov  5 12:53:07 1992
  73. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  74. echo If this archive is complete, you will see the following message:
  75. echo '          "shar: End of archive 1 (of 7)."'
  76. if test -f 'README' -a "${1}" != "-c" ; then 
  77.   echo shar: Will not clobber existing file \"'README'\"
  78. else
  79.   echo shar: Extracting \"'README'\" \(2529 characters\)
  80.   sed "s/^X//" >'README' <<'END_OF_FILE'
  81. X[ Version 1.4 ]
  82. X
  83. X Enclosed you'll find a Prospero client for the archie service.  It'll
  84. Xlet you query the archie databases without actually using an
  85. Xinteractive process on the remote server's machine (e.g., archie.ans.net),
  86. Xresulting in a MUCH better response time.  It also helps lessen the
  87. Xload on the archie server itself.
  88. X
  89. X What's Archie?  It's a system that will let you check a database containing
  90. Xthousands of entries for the files that're available at FTP sites around
  91. Xthe world.
  92. X
  93. X This is a third child of Clifford Neuman's Prospero project.  It's really
  94. Xthe Archie client that's included in the prospero stuff, but I've taken out
  95. Xeverything that's unnecessary for this client to work.  (Aka, you don't
  96. Xhave to build all of Prospero to get the Archie client.)  Khun Yee Fung
  97. Xwrote an archie client in Perl, George Ferguson has written a client
  98. Xfor use with XWindows, based in part upon this code.  Also, Scott
  99. XStark wrote a NeXT-Step client for the NeXT.
  100. X
  101. X Also included in this release is a GNU Emacs Lisp front-end to the
  102. Xarchie client.  Note that it requires the Ange FTP package to work
  103. Xproperly.  You can retrieve it from archive.cis.ohio-state.edu in the
  104. Xdirectory /pub/gnu/emacs/elisp-archive/packages as ange-ftp.tar.Z.
  105. X
  106. X Using the Archie Prospero interface in its true form will probably be of
  107. Xinterest---check out the file `Prospero' for an example of its interface.
  108. XIf you find it intriguing, you should probably get the full prospero kit
  109. Xfrom the University of Washington on cs.washington.edu in pub/prospero.tar.Z.
  110. X
  111. X Suffice to say, there are now a number of ways to query Archie without
  112. Xbogging a server down with your logins.
  113. X
  114. X Check out the man page (or archie.doc, if you're using VMS or DOS)
  115. Xfor instructions on how to use this archie client.  VMS users please
  116. Xnote that you have to put quotes around args that are capital letters;
  117. Xfor example,  `$ ARCHIE "-L"'  to list the available servers.
  118. X
  119. X Please check to make sure you don't have "archie" aliased or modified
  120. Xin some way to do a telnet or rlogin (which you may've done before
  121. Xthis command-line ability came into being).
  122. X
  123. X If Archie consistently hangs (at different times of day with
  124. Xdifferent queries), it's possible that your site has UDP traffic on
  125. Xports > 1000 blocked, for security reasons.  Contact your local
  126. Xsystem administrator.
  127. X
  128. X
  129. X Write to archie-group@cc.mcgill.ca with questions about Archie itself.
  130. X Write to info-prospero@isi.edu about the Prospero protocol.
  131. X Write to brendan@cygnus.com with questions about this specific package.
  132. END_OF_FILE
  133.   if test 2529 -ne `wc -c <'README'`; then
  134.     echo shar: \"'README'\" unpacked with wrong size!
  135.   fi
  136.   # end of 'README'
  137. fi
  138. if test -f 'README.ALEX' -a "${1}" != "-c" ; then 
  139.   echo shar: Will not clobber existing file \"'README.ALEX'\"
  140. else
  141.   echo shar: Extracting \"'README.ALEX'\" \(780 characters\)
  142.   sed "s/^X//" >'README.ALEX' <<'END_OF_FILE'
  143. XAlex is a filesystem that lets users access files in FTP sites around
  144. Xthe world just like they access local files.  The name Alex comes from 
  145. Xthe ancient Library of Alexandria. Alexandria gathered information from 
  146. Xaround the world into one easy to access location. Alex does an analogous 
  147. Xthing in a very modern way.
  148. X
  149. XSource to Alex is now available on alex.sp.cs.cmu.edu in the `src'
  150. Xsubdirectory.
  151. X
  152. Xusenix.wofs92.ps - paper on Alex as published in Usenix Workshop on File Systems 
  153. X                   May of 1992.
  154. X
  155. Xintro.ps         -  same as above paper but with updates
  156. X
  157. X
  158. Xnsf.poster.ps    -  6 slides used for a poster session
  159. X
  160. X
  161. XKeywords:     Alexandria, Alex, technical papers, techreport
  162. XMaster copy:  /alex/edu/cmu/cs/sp/alex/doc/README
  163. X
  164. X
  165. X   Vincent Cate
  166. X   vac@cs.cmu.edu
  167. X
  168. END_OF_FILE
  169.   if test 780 -ne `wc -c <'README.ALEX'`; then
  170.     echo shar: \"'README.ALEX'\" unpacked with wrong size!
  171.   fi
  172.   # end of 'README.ALEX'
  173. fi
  174. if test -f 'README.dos' -a "${1}" != "-c" ; then 
  175.   echo shar: Will not clobber existing file \"'README.dos'\"
  176. else
  177.   echo shar: Extracting \"'README.dos'\" \(10680 characters\)
  178.   sed "s/^X//" >'README.dos' <<'END_OF_FILE'
  179. X11/22/91  Readme.dos -- Readme file for CUTCP DOS version of Archie.
  180. X
  181. X--
  182. XThis version requires the use of a `standard' NCSA or CUTCP compatible
  183. XCONFIG.TEL file.  If you are running NCSA telnet or CUTCP/CUTE telnet,
  184. Xyou should be able to run this program without modification.
  185. X
  186. XAs with all CUTCP programs, you may set a DOS environment variable to
  187. Xpoint to the location of your config.tel file.
  188. X
  189. X    set CONFIGTEL=C:\net\config.tel
  190. X
  191. XYou may also set the $CUTCPnn dos environment variables to include other
  192. X'local' information (such as client IP address on a Novell lan).
  193. X
  194. XThis version has been compiled with the US (archie.sura.net) Prospero/Archie
  195. Xserver as the default. This may not be appropriate for your location. Here's
  196. Xhow to change it.
  197. X
  198. X
  199. X    1. Run the archie program with the -L argument to list known
  200. X       archie/prospero servers.
  201. X
  202. X    2. Select the server name that is closest to your site. For this example
  203. X       we'll pick archie.funet.fi
  204. X
  205. X    3. Edit your config.tel file and add the following lines at the end
  206. X       of the file.
  207. X
  208. X            name=archie
  209. X            host=archie.funet.fi    # actually substitute your select
  210. X                        # server name here
  211. X
  212. X    4. If you happen to know the IP address of the server, you may also
  213. X       add the appropriate
  214. X
  215. X            hostip=<insert IP address here>
  216. X
  217. X    5. If you don't enter an IP address, archie will perform a DNS lookup
  218. X       use the domain nameserver information that is in your config.tel 
  219. X       file.
  220. X
  221. X
  222. XAn additional command line option (-H) has been added (vs -h) to allow the
  223. Xuser to specify the config.tel file location on the command line. 
  224. X
  225. X    archie -H c:\net\config.tel emacs
  226. X
  227. XDuring a search, you may press the <ESCAPE> key to abort the query.
  228. X
  229. X
  230. X
  231. XIf you have problems, try running archie with the -D9 option (debug).
  232. X
  233. XAs usual, bugs/comments to:
  234. X
  235. X        cutcp-bugs@omnigate.clarkson.edu
  236. X
  237. XBrad Clements, Sr. Network Engineer
  238. XEducational Resources Center
  239. XClarkson University 
  240. XPotsdam, NY 13699
  241. X
  242. Xbkc@draco.erc.clarkson.edu
  243. X
  244. X-----------
  245. XSample Config.tel file 
  246. X------------------------------
  247. X#  Example host file for ARCHIE/ CUTCP version
  248. X#  11/21/91
  249. X#
  250. X#      Bugs to  cutcp-bugs@omnigate.clarkson.edu
  251. X
  252. X#---------------------------------------------------------------------------#
  253. X#                                        #
  254. X#** ATTENTION ATTENTION ATTENTION ATTENTION ATTENTION ATTENTION ATTENTION **#
  255. X#                                        #
  256. X#   This sample config.tel file contains every single option that you could #
  257. X#   possibly use. Its meant as an example only. Please Please PLEASE don't  #
  258. X#   use all these options in your working config.tel file, just the ones    #
  259. X#   that you actually need. Many options can be left out, the default action#
  260. X#   (if defined) is shown in parens () next to the option.             #
  261. X#                                        #
  262. X#                         Thank you for your support                #
  263. X#---------------------------------------------------------------------------#
  264. X
  265. X#
  266. X#  This example file is for my=bootp, in which case the following items are
  267. X#  determined from the bootp server: (and are thus commented out in this file)
  268. X#       1. This machine's IP Address
  269. X#       2. The network NETMASK
  270. X#       3. The default gateway (one or more)
  271. X#       4. Nameservers (one or more)
  272. X#       5. The domain search list (if this clients hostname is in the bootp packet)
  273. X#
  274. X#  Your BOOTP server needs to be RFC 1048 compliant for this to work
  275. X#  
  276. X#  If you have nameservers, gateways or a domainslist already specified
  277. X#  in this file, then the file's entry takes precedence.
  278. X#  Extra gateways and nameservers will be added by BOOTP if found, however.
  279. X#----------------------------------------------------------------------------
  280. X#  You can set a DOS environment variable  CONFIGTEL to point to this file
  281. X#  then you don't need batch files or the -h option.
  282. X#
  283. X#       C> set CONFIGTEL=C:\net\myconfig.tel
  284. X#
  285. X#  You may also use environment variables to include config.tel options,
  286. X#  such as:
  287. X#    C> set $CUTCP1=myip~197.001.42.98;netmask~255.255.252.0
  288. X#    C> set $CUTCP2=name~x;hostip~128.163.298.2
  289. X#
  290. X#  and so on up to $CUTCP99. Note that you use a tilde (~) instead of (=)
  291. X#  in the dos set command because two ='s are not allowed by Dos.
  292. X#
  293. X#  Additionally, there is a new config.tel option called include= which
  294. X#  allows the nesting (up to 3) configuration files deep.
  295. X#
  296. X#
  297. X#  You can use these new options on networks to make your configuration job
  298. X#  easier. CUTCP always opens config.tel files as read-only, so you can mark
  299. X#  your files as sharable, read only. Also, you can use the include= command
  300. X#  in a $CUTCP environment variable, and on the command line.
  301. X
  302. X#  *Note* that you can not include a machine specific parameter before
  303. X#  name=default... This used to work in old versions, but is strictly
  304. X#  enforced in this version.
  305. X# --------------------------------------------------------------------------  
  306. X#  This file is free form
  307. X#  Separators are any char <33 and :;=
  308. X#
  309. X#  The form is keyword=value for each parameter.
  310. X#  The first set of parameters refer to the whole program's defaults.
  311. X#  These parameter values can be in any order.
  312. X#  Following this are the individual machine specs.
  313. X#
  314. X
  315. Xmyip=128.153.28.65                      #  (bootp)
  316. X                #  myip types are:
  317. X                                #  bootp        - sends out a BOOTP request for your IP
  318. X                                #  rarp         - Uses reverse ARp to get your IP
  319. X                                #  xx.yy.zz.qq  - your IP address
  320. X
  321. Xvjc=no                # (no)
  322. X                # set  vjc=yes if you're running slip and
  323. X                # you want to use Van Jacobson TCP header
  324. X                # compression
  325. X
  326. Xsplayc=no            # (no) ack. splay compression w/ vjc.. don't
  327. X                # use it, not standard, development option only
  328. X
  329. Xmyname=userid            # put your userid here, used for Rlogin
  330. X                # PC-NFS version ignores this value and uses the name
  331. X                # that you specified to your pcnfsd.
  332. X
  333. Xnetmask=255.255.252.0           #  needed if not using BOOTP. 
  334. X                                #  otherwise not needed because Bootp gets your netmask
  335. X                #  for you
  336. X
  337. Xhardware=packet            # (packet)
  338. X                                # harware choices
  339. X                                #  3com         - 3com 3c501
  340. X                                #  3c523        - 3com 3c523
  341. X                                #  wd800        - Western Digitial 800E
  342. X                                #  nicpc        - 
  343. X                                #  nicps        -
  344. X                                #  ni5210       - Micom Interlan NI5210 card
  345. X                                #  packet       - FTP packet Driver spec 
  346. X                                # (currently only Ethernet and Slip class devices are supported)
  347. X
  348. Xinterrupt=2                     # hardware IRQ interrupt
  349. Xaddress=0                       # (0)
  350. X                # base memory address or packet driver class
  351. X                                # if using packet driver (0 == default == ethernet)
  352. X                                # or class=6 for slip
  353. X
  354. Xioaddr=0                        # (0)
  355. X                # I/O address  or packet int vector if using packet driver
  356. X                                # If = 0 and packet driver, telbin looks for first
  357. X                                # packet driver found between 60H and 7FH
  358. X
  359. Xnoarpme=yes            # Don't arp for myself before running? (no)
  360. X                # if yes, inhibits the initial arp request
  361. X                # for this IP address. However, if yes, won't
  362. X                # warn you if another user is using this IP
  363. X                # address. For some token ring systems, you'll
  364. X                # need noarpme=yes.
  365. X
  366. Xinclude="nul"            # if you want to include another file as part
  367. X                # of this one (you can nest up to three includes)
  368. X                # otherwise, don't use this option
  369. X
  370. Xdomaintime=4            # domain name lookup timeout (first retry)
  371. Xdomainretry=4            # domain name max number of retries 
  372. Xdomainslist="clarkson.edu,aux.clarkson.edu" # domain name search path
  373. X                                # domain name lookup will attach each of these
  374. X                                # comma seperated suffixes to
  375. X                                # the end of the name you are looking for to
  376. X                                # discover the full name and IP address.
  377. X                                # so, looking for x tries x.clarkson.edu and x.aux.clarkson.edu then just x
  378. X                                # unless you use  x.  which ONLY looks for x
  379. X
  380. X    ## Also, the fewer suffixes in the domainslist
  381. X    ## the less time you will have to wait if you mis-type an entry.
  382. X    ## Finally, try not to use a suffix like   .  or .edu or .com this will
  383. X    ## waste a lot of time looking for a bogus host name if you mis-type an entry.
  384. X
  385. X## ----------------------------------------------------------------- ##
  386. X##   BEGIN MACHINE SPECIFIC PARAMETERS...                 ##
  387. X## ----------------------------------------------------------------- ##
  388. X 
  389. Xname=default            # default entry sets defaults for all following
  390. X                # machines.
  391. X
  392. Xarptime=10            # arp timeout in seconds
  393. X                #
  394. X
  395. Xretrans=1                       # starting retransmit time out in ticks
  396. X                #   1/18ths of sec MAX 100, min 1
  397. X
  398. Xmtu=1024                        # maximum transmit unit in bytes
  399. X                #   outgoing packet size, MAX=1500
  400. X
  401. Xmaxseg=1024            # largest segment we can receive
  402. X                #   whatever the hardware can take, MAX=4096
  403. Xrwin=2048                       # most bytes we can receive without ACK
  404. X                #   =TCP window size, MAX=4096
  405. X
  406. Xcontime=20                      # timeout in seconds to try connection
  407. X                #   before returning error to user
  408. X
  409. X#  Following are individual machine specifications
  410. X#  Gateways are used in order that they appear in the file
  411. X#  Nameservers rotate, #1, #2, #3, #1, #2 when a request fails
  412. X#
  413. X
  414. X# ********************************************************************* ###
  415. X# Note: If you are using BOOTP above for myip=, then you do not need
  416. X#       to enter a default gateway, nameserver, netmask etc (unless you want to)
  417. X#       only IF your BOOTP server is rfc_1048 compliant. (Ask your Net Manager)
  418. X#       You can use both bootp and entries here, in which case the entries in
  419. X#       this file over-ride what BOOTP discovers. (however, bootp nameservers
  420. X#       and gateways are ADDED to this file's list of entries
  421. X# ********************************************************************* ####
  422. X
  423. X#  Below this line, most of the communication parameters are obtained
  424. X#  from the "default" host entry.  Those parameters listed for a host 
  425. X#  override the default host values.
  426. X#
  427. X#  These are examples, replace them with the correct values for your site.
  428. X#name=mynameserver
  429. X#host=omnigate.clarkson.edu
  430. X#hostip=197.001.4.2
  431. X#nameserver=1
  432. X
  433. X#name=backupserver
  434. X#host=clutx.clarkson.edu
  435. X#hostip=197.001.4.3
  436. X#nameserver=2
  437. X
  438. X#name=lastserver
  439. X#host=n2ngw.nyser.net
  440. X#hostip=128.145.198.2
  441. X#nameserver=3
  442. X
  443. X#name=mygateway
  444. X#host=nysernet.clarkson.edu
  445. X#hostip=197.001.4.1
  446. X#gateway=1
  447. X
  448. X
  449. Xname=archie
  450. Xhost=archie.funet.fi
  451. END_OF_FILE
  452.   if test 10680 -ne `wc -c <'README.dos'`; then
  453.     echo shar: \"'README.dos'\" unpacked with wrong size!
  454.   fi
  455.   # end of 'README.dos'
  456. fi
  457. if test ! -d 'msdos' ; then
  458.     echo shar: Creating directory \"'msdos'\"
  459.     mkdir 'msdos'
  460. fi
  461. if test ! -d 'vms' ; then
  462.     echo shar: Creating directory \"'vms'\"
  463.     mkdir 'vms'
  464. fi
  465. if test -f 'vms/in.h' -a "${1}" != "-c" ; then 
  466.   echo shar: Will not clobber existing file \"'vms/in.h'\"
  467. else
  468.   echo shar: Extracting \"'vms/in.h'\" \(1418 characters\)
  469.   sed "s/^X//" >'vms/in.h' <<'END_OF_FILE'
  470. X/* netinet/in.h */
  471. Xstruct in_addr
  472. X{
  473. X  union
  474. X  {
  475. X    struct
  476. X    {
  477. X      unsigned char s_b1, s_b2, s_b3, s_b4;
  478. X    } S_un_b;
  479. X    struct
  480. X    {
  481. X      unsigned short s_w1, s_w2;
  482. X    } S_un_w;
  483. X    unsigned long S_addr;
  484. X  } S_un;
  485. X#define   s_addr S_un.S_addr
  486. X#define   s_host S_un.S_un_b.s_b2
  487. X#define   s_net  S_un.S_un_b.s_b1
  488. X#define   s_imp  S_un.S_un_w.s_w2
  489. X#define   s_impno S_un.S_un_b.s_b4
  490. X#define   s_lh   S_un.S_un_b.s_b3
  491. X};
  492. X
  493. X#define INADDR_ANY 0x00000000
  494. X#define INADDR_BROADCAST 0xffffffff
  495. X#define INADDR_LOOPBACK 0x7f000001
  496. X
  497. Xstruct sockaddr_in
  498. X{
  499. X  short sin_family;
  500. X  unsigned short sin_port;
  501. X  struct in_addr sin_addr;
  502. X  char sin_zero[8];
  503. X};
  504. X
  505. X#define ntohl(x) (( (((unsigned long) x) >> 24)& 0x000000ff ) |\
  506. X                  ( (((unsigned long) x) >> 8) & 0x0000ff00 ) |\
  507. X                  ( (((unsigned long) x) << 8) & 0x00ff0000 ) |\
  508. X                  ( (((unsigned long) x) << 24)& 0xff000000 ))
  509. X#define ntohs(x) (( (((unsigned short) x) >> 8) |\
  510. X                  ( (((unsigned short) x) << 8)) & 0xffff ))
  511. X#define htonl(x) (( (((unsigned long) x) >> 24)& 0x000000ff ) |\
  512. X                  ( (((unsigned long) x) >> 8) & 0x0000ff00 ) |\
  513. X                  ( (((unsigned long) x) << 8) & 0x00ff0000 ) |\
  514. X                  ( (((unsigned long) x) << 24)& 0xff000000 ))
  515. X#define htons(x) (( (((unsigned short) x) >> 8) |\
  516. X                  ( (((unsigned short) x) << 8)) & 0xffff ))
  517. X
  518. X#define IPPORT_RESERVED 1024
  519. END_OF_FILE
  520.   if test 1418 -ne `wc -c <'vms/in.h'`; then
  521.     echo shar: \"'vms/in.h'\" unpacked with wrong size!
  522.   fi
  523.   # end of 'vms/in.h'
  524. fi
  525. if test -f 'vms_support.c' -a "${1}" != "-c" ; then 
  526.   echo shar: Will not clobber existing file \"'vms_support.c'\"
  527. else
  528.   echo shar: Extracting \"'vms_support.c'\" \(32780 characters\)
  529.   sed "s/^X//" >'vms_support.c' <<'END_OF_FILE'
  530. X/* Emulation of 4.2 UNIX socket interface routines includes drivers for
  531. X   Wollongong, CMU-TEK, UCX tcp/ip interface and also emulates the SUN
  532. X   version of X.25 sockets.  The TWG will also work for MultiNet.  */
  533. X
  534. X/* This is from unixlib, by P.Kay@massey.ac.nz; wonderful implementation.
  535. X   You can get the real thing on 130.123.1.4 as unixlib_tar.z.  */
  536. X
  537. X#include <stdio.h>
  538. X#include <errno.h>
  539. X#include <ssdef.h>
  540. X#include <dvidef.h>
  541. X#include <signal.h>
  542. X#include <sys$library:msgdef.h>
  543. X#include <iodef.h>
  544. X#include <ctype.h>
  545. X#include <vms.h>
  546. X#include "[.vms]network.h"
  547. X
  548. X#define QIO_FAILED (st != SS$_NORMAL || p[s].iosb[0] != SS$_NORMAL)
  549. X#define QIO_ST_FAILED (st != SS$_NORMAL)
  550. X
  551. X/* Socket routine.  */
  552. Xint
  553. XVMSsocket (domain, type, protocol)
  554. X     int domain, type, protocol;
  555. X{
  556. X  struct descriptor inetdesc, x25desc, mbxdesc;
  557. X  int i, st, s, p_initialise ();
  558. X  long ucx_sock_def;
  559. X  char *getenv ();
  560. X
  561. X  if (!tcp_make)
  562. X    set_tcp_make ();
  563. X
  564. X  if (p_initialised == 0)
  565. X    {
  566. X      for (i = 0; i < 32; i++)
  567. X    p_initialise (i);
  568. X
  569. X      p_initialised = 1;
  570. X    }
  571. X
  572. X  /* First of all, get a file descriptor and file ptr we can associate with
  573. X     the socket, allocate a buffer, and remember the socket details.  */
  574. X  s = dup (0);
  575. X  if (s > 31)
  576. X    {
  577. X      errno = EMFILE;
  578. X      close (s);
  579. X      return -1;
  580. X    }
  581. X
  582. X  p[s].fptr = fdopen (s, "r");
  583. X  p[s].fd_buff = (unsigned char *) malloc (BUF_SIZE);
  584. X  p[s].domain = domain;
  585. X  p[s].type = type;
  586. X  p[s].protocol = protocol;
  587. X
  588. X  /* Handle the case of INET and X.25 separately.  */
  589. X  if (domain == AF_INET)
  590. X    {
  591. X      if (tcp_make == NONE)
  592. X    {
  593. X      printf ("Trying to obtain a TCP socket when we don't have TCP!\n");
  594. X      exit (1);
  595. X    }
  596. X      if (tcp_make == CMU)
  597. X    {
  598. X      /* For CMU we need only assign a channel.  */
  599. X      inetdesc.size = 3;
  600. X      inetdesc.ptr = "IP:";
  601. X      if (sys$assign (&inetdesc, &p[s].channel, 0, 0) != SS$_NORMAL)
  602. X        return -1;
  603. X    }
  604. X      else if (tcp_make == UCX)
  605. X    {
  606. X      /* For UCX assign channel and associate a socket with it.  */
  607. X      inetdesc.size = 3;
  608. X      inetdesc.ptr = "BG:";
  609. X      if (sys$assign (&inetdesc, &p[s].channel, 0, 0) != SS$_NORMAL)
  610. X        return -1;
  611. X
  612. X      ucx_sock_def = (domain << 24) + (type << 16) + protocol;
  613. X      st = sys$qiow (0, p[s].channel, IO$_SETMODE, p[s].iosb, 0, 0,
  614. X             &ucx_sock_def, 0, 0, 0, 0, 0);
  615. X      if (QIO_FAILED)
  616. X        return -1;
  617. X    }
  618. X      else
  619. X    {
  620. X      /* For TWG we assign the channel and associate a socket with it.  */
  621. X      inetdesc.size = 7;
  622. X      inetdesc.ptr = "_INET0:";
  623. X
  624. X      if (sys$assign (&inetdesc, &p[s].channel, 0, 0) != SS$_NORMAL)
  625. X        return -1;
  626. X
  627. X      st = sys$qiow (0, p[s].channel, IO$_SOCKET, p[s].iosb, 0, 0,
  628. X             domain, type, 0, 0, 0, 0);
  629. X      if (QIO_FAILED)
  630. X        return -1;
  631. X    }
  632. X    }
  633. X  else
  634. X    /* We don't handle any other domains yet.  */
  635. X    return -1;
  636. X
  637. X  /* For each case if we are successful we return the descriptor.  */
  638. X  return s;
  639. X}
  640. X
  641. X/* Bind routine.  */
  642. XVMSbind (s, name, namelen)
  643. X     int s;
  644. X     union socket_addr *name;
  645. X     int namelen;
  646. X{
  647. X  char infobuff[1024], lhost[32];
  648. X  int st;
  649. X
  650. X  if (!tcp_make)
  651. X    set_tcp_make ();
  652. X
  653. X  if (p[s].domain == AF_INET)
  654. X    {
  655. X      /* One main problem with bind is that if we're given a port number
  656. X     of 0, then we're expected to return a unique port number.  Since
  657. X     we don't KNOW, we return 1050+s and look to Lady Luck.  */
  658. X      if (tcp_make == CMU)
  659. X    {
  660. X      if (name->in.sin_port == 0 && p[s].type != SOCK_DGRAM)
  661. X        name->in.sin_port = 1050 + s;
  662. X      p[s].namelen = namelen;
  663. X      bcopy (name, &(p[s].name), namelen);
  664. X
  665. X      if (p[s].type == SOCK_DGRAM)
  666. X        {
  667. X          /* Another problem is that CMU still needs an OPEN request
  668. X         even if it's a datagram socket.  */
  669. X          st = sys$qiow (0, p[s].channel, TCP$OPEN, p[s].iosb,
  670. X                 0, 0, 0, 0, ntohs (p[s].name.in.sin_port),
  671. X                 0, 1, 0);
  672. X          if (QIO_ST_FAILED)
  673. X        return -1;
  674. X
  675. X          p[s].cmu_open = 1;
  676. X          sys$qiow (0, p[s].channel, TCP$INFO, p[s].iosb,
  677. X            0, 0, &infobuff, 1024, 0, 0, 0, 0);
  678. X          bcopy (infobuff + 264, &(p[s].name.in.sin_port), 2);
  679. X          p[s].name.in.sin_port = htons (p[s].name.in.sin_port);
  680. X
  681. X          /* So get it another way.  */
  682. X          bcopy (infobuff + 136, lhost, infobuff[1]);
  683. X          lhost[infobuff[1]] = '\0';
  684. X          sys$qiow (0, p[s].channel, GTHST, p[s].iosb,
  685. X            0, 0, &infobuff, 1024, 1, lhost, 0, 0);
  686. X          bcopy (infobuff + 4, &(p[s].name.in.sin_addr), 4);
  687. X
  688. X          /* Be prepared to receive a message.  */
  689. X          hang_a_read (s);
  690. X        }
  691. X    }
  692. X      else if (tcp_make == UCX)
  693. X    {
  694. X      /* UCX will select a prot for you.  If the port's number is 0,
  695. X         translate "name" into an item_2 list.  */
  696. X      struct itemlist lhost;
  697. X      lhost.length = namelen;
  698. X      lhost.code = 0;
  699. X      lhost.dataptr = (char *) name;
  700. X
  701. X      st = sys$qiow (0, p[s].channel, IO$_SETMODE, p[s].iosb, 0, 0,
  702. X             0, 0, &lhost, 0, 0, 0);
  703. X      if (QIO_FAILED)
  704. X        return -1;
  705. X
  706. X      if (p[s].type == SOCK_DGRAM)
  707. X        hang_a_read (s);
  708. X
  709. X    }
  710. X      else
  711. X    {
  712. X      /* WG is more straightforward */
  713. X      st = sys$qiow (0, p[s].channel, IO$_BIND, p[s].iosb,
  714. X             0, 0, name, namelen, 0, 0, 0, 0);
  715. X      if (QIO_FAILED)
  716. X        return -1;
  717. X
  718. X      /* If it's a datagram, get ready for the message.  */
  719. X      if (p[s].type == SOCK_DGRAM)
  720. X        hang_a_read (s);
  721. X    }
  722. X    }
  723. X  else
  724. X    /* We don't handle any other domain yet.  */
  725. X    return -1;
  726. X
  727. X  return 0;
  728. X}
  729. X
  730. X/* Connect routine.  */
  731. XVMSconnect (s, name, namelen)
  732. X     int s;
  733. X     union socket_addr *name;
  734. X     int namelen;
  735. X{
  736. X  int pr, fl, st;
  737. X  char *inet_ntoa ();
  738. X  static struct
  739. X  {
  740. X    int len;
  741. X    char name[128];
  742. X  } gethostbuf;
  743. X  extern int connect_ast ();
  744. X
  745. X  if (!tcp_make)
  746. X    set_tcp_make ();
  747. X
  748. X  /* For datagrams we need to remember who the name was so we can send all
  749. X     messages to that address without having to specify it all the time.  */
  750. X  if (p[s].connected)
  751. X    {
  752. X      if (p[s].connected == 1)
  753. X    errno = EISCONN;
  754. X      else
  755. X    {
  756. X      errno = ECONNREFUSED;
  757. X      p[s].connected = 0;
  758. X    }
  759. X      return -1;
  760. X    }
  761. X
  762. X  if (p[s].connect_pending)
  763. X    {
  764. X      errno = EALREADY;
  765. X      return -1;
  766. X    }
  767. X
  768. X  p[s].passive = 0;
  769. X  p[s].tolen = namelen;
  770. X  bcopy (name, &(p[s].to), namelen);
  771. X
  772. X  if (p[s].domain == AF_INET)
  773. X    {
  774. X      if (tcp_make == CMU)
  775. X    {
  776. X
  777. X      /* Get the info about the remote host  and open up a connection.  */
  778. X      st = sys$qiow (0, p[s].channel, GTHST, p[s].iosb, 0, 0, &gethostbuf,
  779. X             132, 2, name->in.sin_addr.s_addr, 0, 0);
  780. X      if (QIO_FAILED)
  781. X        {
  782. X          strcpy (gethostbuf.name, inet_ntoa (name->in.sin_addr.s_addr));
  783. X          gethostbuf.len = strlen (gethostbuf.name);
  784. X        }
  785. X      gethostbuf.name[gethostbuf.len] = 0;
  786. X
  787. X      /* TCP */
  788. X      pr = 0;
  789. X      /* Active */
  790. X      fl = 1;
  791. X
  792. X      /* Nothing else for datagrams.  */
  793. X      if (p[s].type == SOCK_DGRAM)
  794. X        return (0);
  795. X      st = sys$qio (s, p[s].channel, TCP$OPEN, p[s].iosb, connect_ast,
  796. X            &p[s], &(gethostbuf.name), ntohs (name->in.sin_port),
  797. X            ntohs (p[s].name.in.sin_port), fl, pr, 0);
  798. X      if (QIO_ST_FAILED)
  799. X        return -1;
  800. X    }
  801. X      else if (tcp_make == UCX)
  802. X    {
  803. X      /* Both UDP and TCP can use a connect - IO$_ACCESS */
  804. X      p[s].rhost.length = namelen;
  805. X      p[s].rhost.code = 0;
  806. X      p[s].rhost.dataptr = (char *) name;
  807. X
  808. X      st = sys$qio (s, p[s].channel, IO$_ACCESS, p[s].iosb, connect_ast,
  809. X            &p[s], 0, 0, &p[s].rhost, 0, 0, 0);
  810. X      if (QIO_ST_FAILED)
  811. X        return -1;
  812. X    }
  813. X      else
  814. X    {
  815. X      /* TWG */
  816. X      if (p[s].type == SOCK_DGRAM)
  817. X        return (0);
  818. X      st = sys$qio (s, p[s].channel, IO$_CONNECT, p[s].iosb, connect_ast,
  819. X            &p[s], name, namelen, 0, 0, 0, 0);
  820. X      if (QIO_ST_FAILED)
  821. X        return -1;
  822. X    }
  823. X    }
  824. X  else
  825. X    /* We don't handle any other domain yet.  */
  826. X    return -1;
  827. X
  828. X  if (p[s].non_blocking)
  829. X    {
  830. X      if (p[s].connected)
  831. X    {
  832. X      if (p[s].connected == 1)
  833. X        return 0;
  834. X      else
  835. X        {
  836. X          p[s].connected = 0;
  837. X          errno = ECONNREFUSED;
  838. X          return -1;
  839. X        }
  840. X    }
  841. X      else
  842. X    {
  843. X      p[s].connect_pending = 1;
  844. X      errno = EINPROGRESS;
  845. X      return -1;
  846. X    }
  847. X    }
  848. X  else
  849. X    {
  850. X      /* wait for the connection to occur */
  851. X      if (p[s].connected)
  852. X    {
  853. X      if (p[s].connected == 1)
  854. X        return 0;
  855. X      else
  856. X        {
  857. X          p[s].connected = 0;
  858. X          errno = ECONNREFUSED;
  859. X          return -1;
  860. X        }
  861. X    }
  862. X
  863. X      /* Timed out? */
  864. X      if (wait_efn (s) == -1)
  865. X    return -1;
  866. X
  867. X      if (p[s].connected != SS$_NORMAL)
  868. X    {
  869. X      errno = ECONNREFUSED;
  870. X      return -1;
  871. X    }
  872. X
  873. X      return 0;
  874. X    }
  875. X}
  876. X
  877. X/* Listen routine.  */
  878. XVMSlisten (s, backlog)
  879. X     int s;
  880. X     int backlog;
  881. X{
  882. X  int st;
  883. X
  884. X  if (!tcp_make)
  885. X    set_tcp_make ();
  886. X
  887. X  p[s].passive = 1;
  888. X  p[s].backlog = backlog;
  889. X  if (p[s].domain == AF_INET)
  890. X    {
  891. X      if (tcp_make == CMU)
  892. X    {
  893. X      /* For the CMU sockets we can't do the open call in listen;
  894. X         we have to do it in hang_an_accept, because when we close
  895. X         off the connection we have to be ready to accept another
  896. X         one.  accept() also calls hang_an_accept on the old
  897. X         descriptor.  */
  898. X
  899. X      /* Nothing */
  900. X    }
  901. X      else if (tcp_make == UCX)
  902. X    {
  903. X
  904. X      /* Doc Verbage sez backlog is descriptor of byte.  Doc examples
  905. X         and common sense say backlog is value.  Value doesn't work,
  906. X         so let's try descriptor of byte after all.  */
  907. X      struct descriptor bl;
  908. X      unsigned char ucx_backlog;
  909. X
  910. X      ucx_backlog = (unsigned char) backlog;
  911. X      bl.size = sizeof (ucx_backlog);
  912. X      bl.ptr = (char *) &ucx_backlog;
  913. X
  914. X      st = sys$qiow (0, p[s].channel, IO$_SETMODE, p[s].iosb, 0, 0,
  915. X             0, 0, 0, &bl, 0, 0);
  916. X      if (QIO_FAILED)
  917. X        return -1;
  918. X    }
  919. X      else
  920. X    {
  921. X      /* TWG */
  922. X      st = sys$qiow (0, p[s].channel, IO$_LISTEN, p[s].iosb, 0, 0,
  923. X             backlog, 0, 0, 0, 0, 0);
  924. X      if (QIO_FAILED)
  925. X        return -1;
  926. X    }
  927. X    }
  928. X  else
  929. X    /* We don't handle any other domain yet.  */
  930. X    return -1;
  931. X
  932. X  p[s].status = LISTENING;
  933. X  hang_an_accept (s);
  934. X  return 0;
  935. X}
  936. X
  937. X/* Accept routine.  */
  938. Xint
  939. XVMSaccept (s, addr, addrlen)
  940. X     int s;
  941. X     union socket_addr *addr;
  942. X     int *addrlen;
  943. X{
  944. X  int news, st;
  945. X  struct descriptor inetdesc;
  946. X
  947. X  if (!tcp_make)
  948. X    set_tcp_make ();
  949. X
  950. X  if (p[s].non_blocking && !p[s].accept_pending)
  951. X    {
  952. X      errno = EWOULDBLOCK;
  953. X      return -1;
  954. X    }
  955. X
  956. X  /* hang_an_accept set up an incoming connection request so we have first
  957. X     to hang around until one appears or we time out.  */
  958. X  if (p[s].domain == AF_INET)
  959. X    {
  960. X      if (tcp_make == CMU)
  961. X    {
  962. X      char infobuff[1024];
  963. X
  964. X      /* Timed out?  */
  965. X      if (wait_efn (s) == -1)
  966. X        return -1;
  967. X
  968. X      /* Ok, get a new descriptor ...  */
  969. X      news = dup (0);
  970. X      if (news > 31)
  971. X        {
  972. X          errno = EMFILE;
  973. X          close (news);
  974. X          return -1;
  975. X        }
  976. X
  977. X      /* ... and copy all of our data across.  */
  978. X      bcopy (&p[s], &p[news], sizeof (p[0]));
  979. X
  980. X      /* But not this field, of course! */
  981. X      p[news].s = news;
  982. X
  983. X      sys$qiow (0, p[news].channel, TCP$INFO, p[news].iosb,
  984. X            0, 0, &infobuff, 1024, 0, 0, 0, 0);
  985. X
  986. X      /* Copy across the connection info if necessary.  */
  987. X      if (addr != 0)
  988. X        {
  989. X          *addrlen = sizeof (struct sockaddr_in);
  990. X          bcopy (infobuff + 132, &(addr->in.sin_port), 2);
  991. X          addr->in.sin_port = htons (addr->in.sin_port);
  992. X          addr->in.sin_family = AF_INET;
  993. X          bcopy (infobuff + 272, &(addr->in.sin_addr), 4);
  994. X          p[news].fromlen = *addrlen;
  995. X          bcopy (addr, &(p[news].from), *addrlen);
  996. X        }
  997. X      p[news].status = PASSIVE_CONNECTION;
  998. X
  999. X      /* Get a new file ptr for the socket.  */
  1000. X      p[news].fptr = fdopen (news, "r");
  1001. X
  1002. X      /* Reset this field.  */
  1003. X      p[news].accept_pending = 0;
  1004. X
  1005. X      /* Allocate a buffer.  */
  1006. X      p[news].fd_buff = (unsigned char *) malloc (BUF_SIZE);
  1007. X      p[news].fd_leftover = 0;
  1008. X
  1009. X      /* Be prepared to get msgs.  */
  1010. X      hang_a_read (news);
  1011. X
  1012. X      /* Now fix up our previous socket so it's again listening
  1013. X         for connections.  */
  1014. X      inetdesc.size = 3;
  1015. X      inetdesc.ptr = "IP:";
  1016. X      if (sys$assign (&inetdesc, &p[s].channel, 0, 0) != SS$_NORMAL)
  1017. X        return -1;
  1018. X      p[s].status = LISTENING;
  1019. X      hang_an_accept (s);
  1020. X
  1021. X      /* Return the new socket descriptor.  */
  1022. X      return news;
  1023. X    }
  1024. X      else if (tcp_make == UCX)
  1025. X    {
  1026. X      /* UCX does the actual accept from hang_an_accept.  The accept info
  1027. X        is put into the data structure for the "listening" socket.
  1028. X        These just need to be copied into a newly allocated socket for
  1029. X        the connect and the listening socket re-started.  */
  1030. X
  1031. X      /* Wait for event flag from accept being received inside
  1032. X         of hang_an_accept().  */
  1033. X
  1034. X      if (wait_efn (s) == -1)
  1035. X        /* Timed out.  */
  1036. X        return -1;
  1037. X
  1038. X      /* Ok, get a new descriptor ...  */
  1039. X      news = dup (0);
  1040. X      if (news > 31)
  1041. X        {
  1042. X          errno = EMFILE;
  1043. X          close (news);
  1044. X          return -1;
  1045. X        }
  1046. X      /* ... and copy all of our data across.  */
  1047. X      bcopy (&p[s], &p[news], sizeof (p[0]));
  1048. X      p[news].s = news;    /* but not this field */
  1049. X      p[news].channel = p[s].ucx_accept_chan;
  1050. X
  1051. X      /* Initialize the remote host address item_list_3 struct.  */
  1052. X      p[news].rhost.length = sizeof (struct sockaddr_in);
  1053. X      p[news].rhost.code = 0;
  1054. X      p[news].rhost.dataptr = (char *) &p[news].from;
  1055. X      p[news].rhost.retlenptr = &p[news].fromdummy;
  1056. X
  1057. X      if (addr != 0)
  1058. X        {
  1059. X          /* Return the caller's info, if requested.  */
  1060. X          *addrlen = p[news].fromdummy;
  1061. X          bcopy (&p[news].from, addr, p[news].fromdummy);
  1062. X        }
  1063. X
  1064. X      /* Finish fleshing out the new structure.  */
  1065. X      p[news].status = PASSIVE_CONNECTION;
  1066. X
  1067. X      /* Get a new file pointer for the socket.  */
  1068. X      p[news].fptr = fdopen (news, "r");
  1069. X
  1070. X      /* Reset this field.  */
  1071. X      p[news].accept_pending = 0;
  1072. X
  1073. X      /* Allocate a buffer.  */
  1074. X      p[news].fd_buff = (unsigned char *) malloc (BUF_SIZE);
  1075. X      p[news].fd_leftover = 0;
  1076. X
  1077. X      /* Get it started reading.  */
  1078. X      hang_a_read (news);
  1079. X
  1080. X      p[s].status = LISTENING;
  1081. X      hang_an_accept (s);
  1082. X
  1083. X      return news;
  1084. X    }
  1085. X      else
  1086. X    {
  1087. X      /* TWG */
  1088. X      struct descriptor inetdesc;
  1089. X      int size;
  1090. X
  1091. X      /* Time out?  */
  1092. X      if (wait_efn (s) == -1)
  1093. X        return -1;
  1094. X
  1095. X      /* Ok, get a new descriptor ...  */
  1096. X      news = dup (0);
  1097. X      if (news > 31)
  1098. X        {
  1099. X          errno = EMFILE;
  1100. X          close (news);
  1101. X          return -1;
  1102. X        }
  1103. X
  1104. X      /* Assign a new channel.  */
  1105. X      inetdesc.size = 7;
  1106. X      inetdesc.ptr = "_INET0:";
  1107. X      st = sys$assign (&inetdesc, &p[news].channel, 0, 0);
  1108. X      if (QIO_ST_FAILED)
  1109. X        {
  1110. X          p[s].accept_pending = 0;
  1111. X          sys$clref (s);
  1112. X          return -1;
  1113. X        }
  1114. X
  1115. X      /* From info needs an int length field! */
  1116. X      size = sizeof (p[s].from) + 4;
  1117. X      st = sys$qiow (0, p[news].channel, IO$_ACCEPT, p[news].iosb, 0, 0,
  1118. X             &p[s].fromdummy, size, p[s].channel, 0, 0, 0);
  1119. X
  1120. X      if (QIO_ST_FAILED || p[news].iosb[0] != SS$_NORMAL)
  1121. X        {
  1122. X          p[s].accept_pending = 0;
  1123. X          sys$clref (s);
  1124. X          return -1;
  1125. X        }
  1126. X
  1127. X      if (addr != 0)
  1128. X        {
  1129. X          /* Return the caller's info if requested.  */
  1130. X          *addrlen = p[s].fromdummy;
  1131. X          bcopy (&p[s].from, addr, *addrlen);
  1132. X        }
  1133. X
  1134. X      /* Fix up our new data structure.  */
  1135. X      p[news].status = PASSIVE_CONNECTION;
  1136. X      p[news].domain = AF_INET;
  1137. X      p[news].passive = 1;
  1138. X      p[news].fptr = fdopen (news, "r");
  1139. X      /* Allocate a buffer.  */
  1140. X      p[news].fd_buff = (unsigned char *) malloc (BUF_SIZE);
  1141. X
  1142. X      /* Be prepared to accept msgs.  */
  1143. X      hang_a_read (news);
  1144. X
  1145. X      /* Get the old descriptor back onto accepting.  */
  1146. X      hang_an_accept (s);
  1147. X      return news;
  1148. X    }
  1149. X    }
  1150. X  else
  1151. X    /* We don't handle any other domain yet.  */
  1152. X    return -1;
  1153. X}
  1154. X
  1155. X/* Recv routine.  */
  1156. Xint
  1157. XVMSrecv (s, buf, len, flags)
  1158. X     int s;
  1159. X     char *buf;
  1160. X     int len, flags;
  1161. X{
  1162. X  return recvfrom (s, buf, len, flags, 0, 0);
  1163. X}
  1164. X
  1165. X/* Revfrom routine.  */
  1166. Xint
  1167. XVMSrecvfrom (s, buf, len, flags, from, fromlen)
  1168. X     int s;
  1169. X     char *buf;
  1170. X     int len, flags;
  1171. X     union socket_addr *from;
  1172. X     int *fromlen;
  1173. X{
  1174. X  int number;
  1175. X
  1176. X  if (!tcp_make)
  1177. X    set_tcp_make ();
  1178. X
  1179. X  if (p[s].domain != AF_INET && p[s].domain != AF_X25)
  1180. X    return -1;
  1181. X
  1182. X  /* If we're not onto datagrams, then it's possible that a previous
  1183. X     call to recvfrom didn't read all the data, and left some behind.
  1184. X     So first of all, look in our data buffer for any leftovers that
  1185. X     will satisfy this read.  */
  1186. X
  1187. X  /* We couldn't satisfy the request from previous calls so we must now
  1188. X     wait for a message to come through.  */
  1189. X  if (wait_efn (s) == -1)
  1190. X    /* Timed out.  */
  1191. X    return -1;
  1192. X
  1193. X  if (p[s].closed_by_remote == 1)
  1194. X    {
  1195. X      /* This could have happened! */
  1196. X      errno = ECONNRESET;
  1197. X      return -1;
  1198. X    }
  1199. X
  1200. X  if (from != NULL)
  1201. X    {
  1202. X      if (tcp_make == CMU)
  1203. X    {
  1204. X      if (p[s].type == SOCK_DGRAM)
  1205. X        {
  1206. X          /* Not documented but we get the from data from the beginning of
  1207. X         the data buffer.  */
  1208. X          *fromlen = sizeof (p[s].from.in);
  1209. X          from->in.sin_family = AF_INET;
  1210. X          bcopy (&p[s].fd_buff[8], &(from->in.sin_port), 2);
  1211. X          from->in.sin_port = htons (from->in.sin_port);
  1212. X          bcopy (&p[s].fd_buff[0], &(from->in.sin_addr), 4);
  1213. X
  1214. X          /* Remove the address data from front of data buffer.  */
  1215. X          bcopy (p[s].fd_buff + 12, p[s].fd_buff, p[s].fd_buff_size);
  1216. X        }
  1217. X      else
  1218. X        {
  1219. X          *fromlen = p[s].fromlen;
  1220. X          bcopy (&p[s].from, from, p[s].fromlen);
  1221. X        }
  1222. X    }
  1223. X      else if (tcp_make == UCX)
  1224. X    {
  1225. X      *fromlen = p[s].fromdummy;
  1226. X      bcopy (&p[s].from, from, p[s].fromdummy);
  1227. X    }
  1228. X      else
  1229. X    {
  1230. X      *fromlen = p[s].fromlen;
  1231. X      bcopy (&p[s].from, from, p[s].fromlen);
  1232. X    }
  1233. X    }
  1234. X
  1235. X  /* We may've received too much.  */
  1236. X  number = p[s].fd_buff_size;
  1237. X  if (number <= len)
  1238. X    {
  1239. X      /* If we haven't give back all the data available.  */
  1240. X      bcopy (p[s].fd_buff, buf, number);
  1241. X      p[s].fd_leftover = 0;
  1242. X      hang_a_read (s);
  1243. X      return (number);
  1244. X    }
  1245. X  else
  1246. X    {
  1247. X      /* If we have too much data then split it up.  */
  1248. X      p[s].fd_leftover = p[s].fd_buff;
  1249. X      bcopy (p[s].fd_leftover, buf, len);
  1250. X      /* And change the pointers.  */
  1251. X      p[s].fd_leftover += len;
  1252. X      p[s].fd_buff_size -= len;
  1253. X      return (len);
  1254. X    }
  1255. X}
  1256. X
  1257. X/* Send routine.  */
  1258. Xint
  1259. XVMSsend (s, msg, len, flags)
  1260. X     int s;
  1261. X     char *msg;
  1262. X     int len, flags;
  1263. X{
  1264. X  return sendto (s, msg, len, flags, 0, 0);
  1265. X}
  1266. X
  1267. X/* Sendto routine.  */
  1268. Xint
  1269. XVMSsendto (s, msg, len, flags, to, tolen)
  1270. X     int s;
  1271. X     unsigned char *msg;
  1272. X     int len, flags;
  1273. X     union socket_addr *to;
  1274. X     int tolen;
  1275. X{
  1276. X  int i, j, st, size;
  1277. X  unsigned char udpbuf[BUF_SIZE + 12];
  1278. X  char infobuff[1024], lhost[32];
  1279. X  unsigned short int temp;
  1280. X
  1281. X  if (!tcp_make)
  1282. X    set_tcp_make ();
  1283. X
  1284. X  /* First remember who we sent it to and set the value of size.  */
  1285. X  if (to != 0)
  1286. X    {
  1287. X      p[s].tolen = tolen;
  1288. X      bcopy (to, &(p[s].to), tolen);
  1289. X      size = tolen;
  1290. X    }
  1291. X  else
  1292. X    size = 0;
  1293. X
  1294. X  if (p[s].domain == AF_INET)
  1295. X    {
  1296. X      /* We might never have started a read for udp (socket/sendto) so
  1297. X     put one here.  */
  1298. X      if (p[s].type == SOCK_DGRAM)
  1299. X    hang_a_read (s);
  1300. X
  1301. X      if (tcp_make == CMU)
  1302. X    {
  1303. X      if (p[s].type == SOCK_DGRAM)
  1304. X        {
  1305. X          /* We might never have opened up a udp connection yet,
  1306. X         so check.  */
  1307. X          if (p[s].cmu_open != 1)
  1308. X        {
  1309. X          st = sys$qiow (0, p[s].channel, TCP$OPEN, p[s].iosb, 0, 0,
  1310. X                 0, 0, 0, 0, 1, 0);
  1311. X          if (QIO_ST_FAILED)
  1312. X            return -1;
  1313. X
  1314. X          p[s].cmu_open = 1;
  1315. X          sys$qiow (0, p[s].channel, TCP$INFO, p[s].iosb,
  1316. X                0, 0, &infobuff, 1024, 0, 0, 0, 0);
  1317. X          bcopy (infobuff + 264, &(p[s].name.in.sin_port), 2);
  1318. X          p[s].name.in.sin_port = htons (p[s].name.in.sin_port);
  1319. X          bcopy (infobuff + 136, lhost, infobuff[1]);
  1320. X          lhost[infobuff[1]] = '\0';
  1321. X          sys$qiow (0, p[s].channel, GTHST, p[s].iosb,
  1322. X                0, 0, &infobuff, 1024, 1, lhost, 0, 0);
  1323. X          bcopy (infobuff + 4, &(p[s].name.in.sin_addr), 4);
  1324. X        }
  1325. X
  1326. X          /* This isn't well documented.  To send to a UDP socket, we
  1327. X         need to put the address info at the beginning of the
  1328. X         buffer.  */
  1329. X          bcopy (msg, udpbuf + 12, len);
  1330. X          bcopy (&p[s].to.in.sin_addr, udpbuf + 4, 4);
  1331. X          temp = ntohs (p[s].to.in.sin_port);
  1332. X          bcopy (&temp, udpbuf + 10, 2);
  1333. X          bcopy (&p[s].name.in.sin_addr, udpbuf, 4);
  1334. X          temp = ntohs (p[s].name.in.sin_port);
  1335. X          bcopy (&temp, udpbuf + 8, 2);
  1336. X          temp = len + 12;
  1337. X          st = sys$qiow (0, p[s].channel, TCP$SEND, p[s].iosb, 0, 0,
  1338. X                 udpbuf, temp, 0, 0, 0, 0);
  1339. X          if (QIO_FAILED)
  1340. X        return -1;
  1341. X        }
  1342. X      else
  1343. X        {
  1344. X          /* TCP (! UDP)  */
  1345. X          st = sys$qiow (0, p[s].channel, TCP$SEND, p[s].iosb, 0, 0,
  1346. X                 msg, len, 0, 0, 0, 0);
  1347. X          if (QIO_FAILED)
  1348. X        return -1;
  1349. X        }
  1350. X      return len;
  1351. X    }
  1352. X      else if (tcp_make == UCX)
  1353. X    {
  1354. X      struct itemlist rhost;
  1355. X      rhost.length = sizeof (struct sockaddr_in);
  1356. X      rhost.code = 0;
  1357. X      rhost.dataptr = (char *) &p[s].to;
  1358. X
  1359. X      st = sys$qiow (0, p[s].channel, IO$_WRITEVBLK, p[s].iosb, 0, 0,
  1360. X             msg, len, &rhost, 0, 0, 0);
  1361. X      if (QIO_FAILED)
  1362. X        return -1;
  1363. X
  1364. X      return len;
  1365. X    }
  1366. X      else
  1367. X    {
  1368. X      /* TWG */
  1369. X      st = sys$qiow (0, p[s].channel, IO$_WRITEVBLK, p[s].iosb,
  1370. X             0, 0, msg, len, 0, &p[s].to, size, 0);
  1371. X      if (QIO_FAILED)
  1372. X        return -1;
  1373. X
  1374. X      return len;
  1375. X    }
  1376. X    }
  1377. X  else
  1378. X    /* We don't handle any other domain yet.  */
  1379. X    return -1;
  1380. X}
  1381. X
  1382. X/* Getsockname routine.  */
  1383. Xint
  1384. XVMSgetsockname (s, name, namelen)
  1385. X     int s;
  1386. X     union socket_addr *name;
  1387. X     int *namelen;
  1388. X{
  1389. X  int st;
  1390. X
  1391. X  if (!tcp_make)
  1392. X    set_tcp_make ();
  1393. X
  1394. X  if (p[s].domain == AF_INET)
  1395. X    {
  1396. X      if (tcp_make == CMU)
  1397. X    {
  1398. X      /* For CMU we just return values held in our data structure.  */
  1399. X      *namelen = p[s].namelen;
  1400. X      bcopy (&(p[s].name), name, *namelen);
  1401. X      return (0);
  1402. X    }
  1403. X      else if (tcp_make == UCX)
  1404. X    {
  1405. X      /* An item_list_3 descriptor.  */
  1406. X      struct itemlist lhost;
  1407. X
  1408. X      lhost.length = *namelen;
  1409. X      lhost.code = 0;
  1410. X      lhost.dataptr = (char *) name;
  1411. X
  1412. X      /* Fill in namelen with actual ret len value.  */
  1413. X      lhost.retlenptr = (short int *) namelen;
  1414. X
  1415. X      st = sys$qiow (0, p[s].channel, IO$_SENSEMODE, p[s].iosb, 0, 0,
  1416. X             0, 0, &lhost, 0, 0, 0);
  1417. X      if (QIO_FAILED)
  1418. X        return -1;
  1419. X
  1420. X      return 0;
  1421. X    }
  1422. X      else
  1423. X    {
  1424. X      /* TWG gives us the information. */
  1425. X      st = sys$qiow (0, p[s].channel, IO$_GETSOCKNAME, p[s].iosb,
  1426. X             0, 0, name, namelen, 0, 0, 0, 0);
  1427. X      if (QIO_FAILED)
  1428. X        return -1;
  1429. X
  1430. X      return 0;
  1431. X    }
  1432. X    }
  1433. X  else
  1434. X    /* We don't handle any other domain yet.  */
  1435. X    return -1;
  1436. X}
  1437. X
  1438. X/* Select routine.  */
  1439. Xint
  1440. XVMSselect (nfds, readfds, writefds, exceptfds, timeout)
  1441. X     int nfds;
  1442. X     fd_set *readfds, *writefds, *exceptfds;
  1443. X     struct timeval *timeout;
  1444. X{
  1445. X  int timer, fd, alarm_set, total, end;
  1446. X  long mask, cluster;
  1447. X  struct descriptor termdesc;
  1448. X  static fd_set new_readfds, new_writefds, new_exceptfds;
  1449. X
  1450. X  FD_ZERO (&new_readfds);
  1451. X  FD_ZERO (&new_writefds);
  1452. X  FD_ZERO (&new_exceptfds);
  1453. X  total = 0;
  1454. X
  1455. X  /* Assign a terminal channel if we haven't already.  */
  1456. X  if (terminal.chan == -1)
  1457. X    {
  1458. X      termdesc.size = 10;
  1459. X      termdesc.ptr = "SYS$INPUT:";
  1460. X      sys$assign (&termdesc, &terminal.chan, 0, 0);
  1461. X    }
  1462. X  alarm_set = 0;
  1463. X  if (timeout != NULL)
  1464. X    {
  1465. X      /* If a timeout is given then set the alarm.  */
  1466. X      end = timeout->tv_sec;
  1467. X      if (timer != 0)
  1468. X    {
  1469. X      /* We need to reset the alarm if it didn't fire, but we set it.  */
  1470. X      alarm_set = 1;
  1471. X      si_alarm (end);
  1472. X    }
  1473. X    }
  1474. X  else
  1475. X    end = 1;
  1476. X
  1477. X  do
  1478. X    {
  1479. X      if (exceptfds)
  1480. X    {
  1481. X       /* Nothing */ ;
  1482. X    }
  1483. X
  1484. X      if (writefds)
  1485. X    {
  1486. X      for (fd = 0; fd < nfds; fd++)
  1487. X        if (FD_ISSET (fd, writefds))
  1488. X          {
  1489. X        if (p[fd].connect_pending)
  1490. X           /* Nothing */ ;
  1491. X        else if ((p[fd].status == ACTIVE_CONNECTION)
  1492. X             || (p[fd].status == PASSIVE_CONNECTION))
  1493. X          {
  1494. X            FD_SET (fd, &new_writefds);
  1495. X            total++;
  1496. X          }
  1497. X          }
  1498. X    }
  1499. X
  1500. X      if (readfds)
  1501. X    {
  1502. X      /* True if data pending or an accept.  */
  1503. X      for (fd = 3; fd < nfds; fd++)
  1504. X        if (FD_ISSET (fd, readfds) &&
  1505. X        ((p[fd].fd_buff_size != -1) || (p[fd].accept_pending == 1)))
  1506. X          {
  1507. X        FD_SET (fd, &new_readfds);
  1508. X        total++;
  1509. X          }
  1510. X    }
  1511. X
  1512. X      if (total || (end == 0))
  1513. X    break;
  1514. X
  1515. X      /* Otherwise, wait on an event flag.  It's possible that the wait can
  1516. X     be stopped by a spurious event flag being set -- i.e. one that's
  1517. X     got a status not normal.  So we've got to be prepared to loop
  1518. X     around the wait until a valid reason happens.  */
  1519. X
  1520. X      /* Set up the wait mask.  */
  1521. X      cluster = 0;
  1522. X      mask = 0;
  1523. X      for (fd = 3; fd < nfds; fd++)
  1524. X    {
  1525. X      sys$clref (fd);
  1526. X      if (readfds)
  1527. X        if FD_ISSET
  1528. X          (fd, readfds) mask |= (1 << fd);
  1529. X      if (writefds)
  1530. X        if FD_ISSET
  1531. X          (fd, writefds) mask |= (1 << fd);
  1532. X      if (exceptfds)
  1533. X        if FD_ISSET
  1534. X          (fd, exceptfds) mask |= (1 << fd);
  1535. X    }
  1536. X
  1537. X      mask |= (1 << TIMER_EFN);
  1538. X
  1539. X      /* Clear it off just in case.  */
  1540. X      sys$clref (TIMER_EFN);
  1541. X
  1542. X      /* Wait around.  */
  1543. X      sys$wflor (cluster, mask);
  1544. X
  1545. X      mask = 0;
  1546. X      if (read_efn (TIMER_EFN))
  1547. X    {
  1548. X      errno = EINTR;
  1549. X      break;
  1550. X    }
  1551. X  } while (1);
  1552. X  /*NOTREACHED*/
  1553. X
  1554. X  /* Unset the alarm if we set it.  */
  1555. X  if (alarm_set == 1)
  1556. X    alarm (0);
  1557. X
  1558. X  if (readfds)
  1559. X    *readfds = new_readfds;
  1560. X
  1561. X  if (writefds)
  1562. X    *writefds = new_writefds;
  1563. X
  1564. X  if (exceptfds)
  1565. X    *exceptfds = new_exceptfds;
  1566. X
  1567. X  return total;
  1568. X}
  1569. X
  1570. X/* Shutdown routine.  */
  1571. XVMSshutdown (s, how)
  1572. X     int s, how;
  1573. X{
  1574. X  int st;
  1575. X  int ucx_how;
  1576. X
  1577. X  if (!tcp_make)
  1578. X    set_tcp_make ();
  1579. X
  1580. X  if (p[s].domain == AF_INET)
  1581. X    {
  1582. X      if (tcp_make == CMU)
  1583. X    {
  1584. X      /* For CMU we just close off.  */
  1585. X      si_close (s);
  1586. X      return 0;
  1587. X    }
  1588. X      else if (tcp_make == UCX)
  1589. X    {
  1590. X      st = sys$qiow (0, p[s].channel, IO$_DEACCESS | IO$M_SHUTDOWN,
  1591. X             p[s].iosb, 0, 0, 0, 0, 0, how, 0, 0);
  1592. X      if (QIO_FAILED)
  1593. X        return -1;
  1594. X
  1595. X      return 0;
  1596. X    }
  1597. X      else
  1598. X    {
  1599. X      /* TWG lets us do it.  */
  1600. X      st = sys$qiow (0, p[s].channel, IO$_SHUTDOWN, p[s].iosb, 0, 0, how,
  1601. X             0, 0, 0, 0, 0);
  1602. X      if (QIO_FAILED)
  1603. X        return -1;
  1604. X
  1605. X      return 0;
  1606. X    }
  1607. X    }
  1608. X  else                /* it wasn't a socket */
  1609. X    return -1;
  1610. X}
  1611. X
  1612. X/*   */
  1613. X
  1614. X/* The following routines are used by the above socket calls.  */
  1615. X
  1616. X/* hang_a_read sets up a read to be finished at some later time.  */
  1617. Xhang_a_read (s)
  1618. X     int s;
  1619. X{
  1620. X  extern int read_ast ();
  1621. X  int size, st;
  1622. X
  1623. X  /* Don't bother if we already did it.  */
  1624. X  if (p[s].read_outstanding == 1)
  1625. X    return;
  1626. X
  1627. X  /* Have a read outstanding.  */
  1628. X  p[s].read_outstanding = 1;
  1629. X  size = sizeof (p[s].from) + 4;
  1630. X  sys$clref (s);
  1631. X
  1632. X  /* Clear off the event flag just in case, and reset the buf size.  */
  1633. X  p[s].fd_buff_size = -1;
  1634. X  if (p[s].domain == AF_INET)
  1635. X    {
  1636. X      if (tcp_make == CMU)
  1637. X    {
  1638. X      st = sys$qio (s, p[s].channel, TCP$RECEIVE, p[s].iosb, read_ast,
  1639. X            &p[s], p[s].fd_buff, BUF_SIZE, 0, 0, 0, 0);
  1640. X      if (QIO_ST_FAILED)
  1641. X        return -1;
  1642. X    }
  1643. X      else if (tcp_make == UCX)
  1644. X    {
  1645. X
  1646. X      p[s].rhost.length = sizeof (struct sockaddr_in);
  1647. X      p[s].rhost.code = 0;
  1648. X      p[s].rhost.dataptr = (char *) &p[s].from;
  1649. X      p[s].rhost.retlenptr = &p[s].fromdummy;
  1650. X
  1651. X      st = sys$qio (s, p[s].channel, IO$_READVBLK, p[s].iosb, read_ast,
  1652. X            &p[s], p[s].fd_buff, BUF_SIZE, &p[s].rhost, 0, 0, 0);
  1653. X      if (QIO_ST_FAILED)
  1654. X        return -1;
  1655. X    }
  1656. X      else
  1657. X    {
  1658. X      /* TWG */
  1659. X      st = sys$qio (s, p[s].channel, IO$_READVBLK, p[s].iosb, read_ast,
  1660. X            &p[s], p[s].fd_buff, BUF_SIZE, 0, &p[s].fromlen,
  1661. X            size, 0);
  1662. X      if (QIO_ST_FAILED)
  1663. X        return -1;
  1664. X    }
  1665. X    }
  1666. X  else
  1667. X    /* We don't handle any other domain yet.  */
  1668. X    return -1;
  1669. X}
  1670. X
  1671. X/* hang_an_accept waits for a connection request to come in.  */
  1672. Xhang_an_accept (s)
  1673. X     int s;
  1674. X{
  1675. X  extern int accept_ast ();
  1676. X  int st;
  1677. X
  1678. X  /* Clear the event flag just in case.  */
  1679. X  sys$clref (s);
  1680. X
  1681. X  /* Reset our flag & buf size.  */
  1682. X  p[s].accept_pending = 0;
  1683. X  p[s].fd_buff_size = -1;
  1684. X  if (p[s].domain == AF_INET)
  1685. X    {
  1686. X      if (tcp_make == CMU)
  1687. X    {
  1688. X      st = sys$qio (s, p[s].channel, TCP$OPEN, p[s].iosb, accept_ast,
  1689. X            &p[s], 0, 0, ntohs (p[s].name.in.sin_port), 0, 0, 0);
  1690. X      if (QIO_ST_FAILED)
  1691. X        return -1;
  1692. X    }
  1693. X      else if (tcp_make == UCX)
  1694. X    {
  1695. X      struct descriptor inetdesc;
  1696. X
  1697. X      /* Assign channel for actual connection off listener.  */
  1698. X      inetdesc.size = 3;
  1699. X      inetdesc.ptr = "BG:";
  1700. X      if (sys$assign (&inetdesc, &p[s].ucx_accept_chan, 0,
  1701. X              0) != SS$_NORMAL)
  1702. X        return -1;
  1703. X
  1704. X      /* UCX's accept returns remote host info and the channel for a new
  1705. X         socket to perform reads/writes on, so a sys$assign isn't
  1706. X         really necessary.  */
  1707. X      p[s].rhost.length = sizeof (struct sockaddr_in);
  1708. X      p[s].rhost.dataptr = (char *) &p[s].from;
  1709. X      p[s].fromdummy = 0;
  1710. X      p[s].rhost.retlenptr = &p[s].fromdummy;
  1711. X
  1712. X      st = sys$qio (s, p[s].channel, IO$_ACCESS | IO$M_ACCEPT, p[s].iosb,
  1713. X            accept_ast, &p[s], 0, 0, &p[s].rhost,
  1714. X            &p[s].ucx_accept_chan, 0, 0);
  1715. X      if (QIO_ST_FAILED)
  1716. X        return -1;
  1717. X    }
  1718. X      else
  1719. X    {
  1720. X      st = sys$qio (s, p[s].channel, IO$_ACCEPT_WAIT, p[s].iosb,
  1721. X            accept_ast, &p[s], 0, 0, 0, 0, 0, 0);
  1722. X      if (QIO_ST_FAILED)
  1723. X        return -1;
  1724. X    }
  1725. X    }
  1726. X  else
  1727. X    /* We don't handle any other domain yet.  */
  1728. X    return -1;
  1729. X}
  1730. X
  1731. X/* wait_efn just sets up a wait on either an event or the timer.  */
  1732. Xwait_efn (s)
  1733. X     int s;
  1734. X{
  1735. X  long mask, cluster;
  1736. X
  1737. X  cluster = 0;
  1738. X  sys$clref (TIMER_EFN);
  1739. X  mask = (1 << s) | (1 << TIMER_EFN);
  1740. X  sys$wflor (cluster, mask);
  1741. X
  1742. X  if (read_efn (TIMER_EFN))
  1743. X    {
  1744. X      errno = EINTR;
  1745. X      return -1;
  1746. X    }
  1747. X
  1748. X  return 0;
  1749. X}
  1750. X
  1751. X/* read_ast is called by the system whenever a read is done.  */
  1752. Xread_ast (p)
  1753. X     struct fd_entry *p;
  1754. X{
  1755. X  int i, j;
  1756. X  unsigned char *v, *w;
  1757. X
  1758. X  /* Reset the outstanding flag.  */
  1759. X  p->read_outstanding = 0;
  1760. X  if (p->iosb[0] == SS$_NORMAL)
  1761. X    {
  1762. X      /* Check no errors.  */
  1763. X      p->fd_buff_size = p->iosb[1];
  1764. X      if (tcp_make == CMU)
  1765. X    {
  1766. X      /* fiddle for DGRMs */
  1767. X      if (p->type == SOCK_DGRAM)
  1768. X        p->fd_buff_size -= 12;
  1769. X    }
  1770. X      if (p->sig_req == 1)
  1771. X    gsignal (SIGIO);
  1772. X    }
  1773. X  else if (p->iosb[0] == SS$_CLEARED)
  1774. X    p->closed_by_remote = 1;
  1775. X  else if (tcp_make == UCX)
  1776. X    {
  1777. X      if (p->iosb[0] == SS$_LINKDISCON)
  1778. X    p->closed_by_remote = 1;
  1779. X    }
  1780. X}
  1781. X
  1782. X/* accept_ast is called whenever an incoming call is detected.  */
  1783. Xaccept_ast (p)
  1784. X     struct fd_entry *p;
  1785. X{
  1786. X  if (p->iosb[0] == SS$_NORMAL)
  1787. X    p->accept_pending = 1;
  1788. X  else
  1789. X    /* If it failed set up another listen.  */
  1790. X    listen (p->s, p[p->s].backlog);
  1791. X}
  1792. X
  1793. X/* connect_ast is called whenever an async connect is made.  */
  1794. Xconnect_ast (p)
  1795. X     struct fd_entry *p;
  1796. X{
  1797. X  p->connect_pending = 0;
  1798. X  if ((p->connected = p->iosb[0]) == SS$_NORMAL)
  1799. X    {
  1800. X      /* We made the connection.  */
  1801. X      p->status = ACTIVE_CONNECTION;
  1802. X
  1803. X      /* Be prepared to accept a msg.  */
  1804. X      hang_a_read (p->s);
  1805. X    }
  1806. X}
  1807. X
  1808. X/*   */
  1809. X/* These routines handle stream I/O.  */
  1810. X
  1811. X/* si_close -- must close off any connection in progress.  */
  1812. Xsi_close (s)
  1813. X     int s;
  1814. X{
  1815. X  if (!tcp_make)
  1816. X    set_tcp_make ();
  1817. X
  1818. X  if ((s < 0) || (s > 31))
  1819. X    return -1;
  1820. X
  1821. X  if (p[s].channel != 0)
  1822. X    {
  1823. X      /* Was it one of our descriptors? */
  1824. X      if (p[s].domain == AF_INET)
  1825. X    {
  1826. X      if (tcp_make == CMU)
  1827. X        sys$qiow (0, p[s].channel, TCP$CLOSE, p[s].iosb,
  1828. X              0, 0, 0, 0, 0, 0, 0, 0);
  1829. X      if (p[s].status != HANDED_OFF)
  1830. X        sys$dassgn (p[s].channel);
  1831. X      close (s);
  1832. X      free (p[s].fd_buff);
  1833. X      p_initialise (s);
  1834. X    }
  1835. X      return 0;
  1836. X    }
  1837. X  else
  1838. X    {
  1839. X      /* Re-initialise data structure just in case.  */
  1840. X      p[s].fd_buff_size = -1;
  1841. X      p[s].accept_pending = 0;
  1842. X      p[s].status = INITIALISED;
  1843. X      return close (s);
  1844. X    }
  1845. X}
  1846. X
  1847. X/* si_alarm -- insert a call to our own alarm function.  */
  1848. Xsi_alarm (i)
  1849. X     int i;
  1850. X{
  1851. X  extern int pre_alarm ();
  1852. X
  1853. X  /* Make the call to pre_alarm instead of what the user wants;
  1854. X     pre_alarm will call his routine when it finishes.  */
  1855. X  /* VAX needs this call each time! */
  1856. X  signal (SIGALRM, pre_alarm);
  1857. X  alarm (i);
  1858. X}
  1859. X
  1860. X/* pre_alarm -- gets called first on an alarm signal.  */
  1861. Xpre_alarm ()
  1862. X{
  1863. X  /* Come here first so we can set our timer event flag.  */
  1864. X  sys$setef (TIMER_EFN);
  1865. X  (*alarm_function) ();
  1866. X}
  1867. X
  1868. X/* p_initialise - initialise our data array.  */
  1869. Xp_initialise (s)
  1870. X     int s;
  1871. X{
  1872. X  int j;
  1873. X  for (j = 0; j < 4; j++)
  1874. X    p[s].iosb[j] = 0;
  1875. X  p[s].channel = 0;
  1876. X  p[s].fd_buff_size = -1;
  1877. X  p[s].accept_pending = 0;
  1878. X  p[s].connect_pending = 0;
  1879. X  p[s].connected = 0;
  1880. X  p[s].fd_buff = NULL;
  1881. X  p[s].fd_leftover = NULL;
  1882. X  p[s].fptr = NULL;
  1883. X  p[s].s = s;
  1884. X  p[s].name.in.sin_port = 0;
  1885. X  p[s].masklen = 4;
  1886. X  for (j = 0; j < 16; j++)
  1887. X    p[s].mask[j] = 0xff;
  1888. X  p[s].need_header = 0;
  1889. X  p[s].status = INITIALISED;
  1890. X  p[s].read_outstanding = 0;
  1891. X  p[s].cmu_open = 0;
  1892. X  p[s].x25_listener = 0;
  1893. X  p[s].mother = s;
  1894. X  p[s].child = 0;
  1895. X  p[s].no_more_accepts = 0;
  1896. X  p[s].closed_by_remote = 0;
  1897. X  p[s].non_blocking = 0;
  1898. X  p[s].sig_req = 0;
  1899. X  sys$clref (s);
  1900. X}
  1901. X
  1902. X/* read_efn -- see whether an event flag is set.  */
  1903. Xread_efn (i)
  1904. X     int i;
  1905. X{
  1906. X  int j;
  1907. X  sys$readef (i, &j);
  1908. X  j &= (1 << i);
  1909. X
  1910. X  return j;
  1911. X}
  1912. X
  1913. Xstatic
  1914. Xset_tcp_make ()
  1915. X{
  1916. X  struct descriptor inetdesc;
  1917. X  int channel;
  1918. X  /* first try CMU */
  1919. X  inetdesc.size = 3;
  1920. X  inetdesc.ptr = "IP:";
  1921. X  if (sys$assign (&inetdesc, &channel, 0, 0) == SS$_NORMAL)
  1922. X    {
  1923. X      sys$dassgn (channel);
  1924. X      tcp_make = CMU;
  1925. X      return;
  1926. X    }
  1927. X
  1928. X  /* next try TWG */
  1929. X  inetdesc.size = 7;
  1930. X  inetdesc.ptr = "_INET0:";
  1931. X  if (sys$assign (&inetdesc, &channel, 0, 0) == SS$_NORMAL)
  1932. X    {
  1933. X      sys$dassgn (channel);
  1934. X      tcp_make = WG;
  1935. X      return;
  1936. X    }
  1937. X
  1938. X  /* next try UCX */
  1939. X  inetdesc.size = 4;
  1940. X  inetdesc.ptr = "BG0:";
  1941. X  if (sys$assign (&inetdesc, &channel, 0, 0) == SS$_NORMAL)
  1942. X    {
  1943. X      sys$dassgn (channel);
  1944. X      tcp_make = UCX;
  1945. X      return;
  1946. X    }
  1947. X
  1948. X  /* nothing there oh dear!*/
  1949. X  tcp_make = NONE;
  1950. X  return;
  1951. X}
  1952. X
  1953. Xstatic char *
  1954. Xgetdevicename (channel)
  1955. X     unsigned short int channel;
  1956. X{
  1957. X  int st;
  1958. X  struct
  1959. X  {
  1960. X    struct itemlist id;
  1961. X    int eol;
  1962. X  } itmlst;
  1963. X  static char name[64];
  1964. X  short int lgth;
  1965. X
  1966. X  name[0] = '\0';
  1967. X  itmlst.id.code = DVI$_DEVNAM;
  1968. X  itmlst.id.length = 64;
  1969. X  itmlst.id.dataptr = name;
  1970. X  itmlst.id.retlenptr = &lgth;
  1971. X  itmlst.eol = 0;
  1972. X  st = sys$getdvi (0, channel, 0, &itmlst, 0, 0, 0, 0);
  1973. X  if (QIO_ST_FAILED)
  1974. X    fprintf (stderr, "error getting device name %d\n", st);
  1975. X
  1976. X  return (name);
  1977. X}
  1978. END_OF_FILE
  1979.   if test 32780 -ne `wc -c <'vms_support.c'`; then
  1980.     echo shar: \"'vms_support.c'\" unpacked with wrong size!
  1981.   fi
  1982.   # end of 'vms_support.c'
  1983. fi
  1984. echo shar: End of archive 1 \(of 7\).
  1985. cp /dev/null ark1isdone
  1986. MISSING=""
  1987. for I in 1 2 3 4 5 6 7 ; do
  1988.     if test ! -f ark${I}isdone ; then
  1989.     MISSING="${MISSING} ${I}"
  1990.     fi
  1991. done
  1992. if test "${MISSING}" = "" ; then
  1993.     echo You have unpacked all 7 archives.
  1994.     rm -f ark[1-9]isdone
  1995. else
  1996.     echo You still must unpack the following archives:
  1997.     echo "        " ${MISSING}
  1998. fi
  1999. exit 0
  2000. exit 0 # Just in case...
  2001.