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