home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3555 < prev    next >
Internet Message Format  |  1991-06-26  |  60KB
  1. From: brnstnd@kramden.acf.nyu.edu (Dan Bernstein)
  2. Newsgroups: alt.sources
  3. Subject: clientserver 0.50 (part 1/2)
  4. Message-ID: <11300.Jun2522.45.0291@kramden.acf.nyu.edu>
  5. Date: 25 Jun 1991 22:45:02 GMT
  6.  
  7. This is clientserver 0.50, a set of three client-server suites
  8. supporting different protocols with the same well-defined interface. Two
  9. of the suites support the TCP and UNDOM protocols for BSD systems; one
  10. supports the NPIPE protocol for System V. (I'd love to hear from anyone
  11. with a System V more modern than a 3B2: Does NPIPE run on your machine?)
  12. All obey the UCSPI (UNIX Client-Server Program Interface) standard, so
  13. you can write programs that work exactly the same way on top of any of
  14. the protocols. You can even use these communications facilities inside
  15. shell scripts.
  16.  
  17. Why do you want to use UCSPI-compliant communications tools? One
  18. advantage is instant portability. By working with the client-server
  19. model given here, you instantly make your programs usable over the
  20. Internet as well as on System V machines. Not only that, but your code
  21. will work with any future communications tools designed to fit the
  22. standard. Imagine supporting DECnet, AT&T's TLI, even Kerberos without
  23. lifting a finger! Another advantage is modularity: you can mix 'n' match
  24. protocols and applications without worrying which program supports which
  25. protocols. Finally, you can skip all those nasty steps of getting
  26. connection information from the operating system. No matter what the
  27. protocol is, UCSPI insists that you be given environment variables
  28. saying who you're talking to.
  29.  
  30. UCSPI also mandates an often ignored aspect of client-server
  31. communications: a standard way to kill the server. You don't have to go
  32. searching through process lists or checking /etc/syslog.pid or sending
  33. HUPS left and right. You stop a server the same way you started it. You
  34. might set up a telnet daemon, for example, with this command:
  35.  
  36.   tcpserver 0 telnet sh -c '/usr/etc/in.telnetd <&6 >&7 6<&- 7>&-' &
  37.  
  38. Here 0 refers to the local machine, and telnet is a port. To kill the
  39. server you just have to know the address:
  40.  
  41.   tcpkiller 0 telnet
  42.  
  43. That's it.
  44.  
  45. Everything here except the UCSPI-91 standard is in the public domain.
  46. Feel free to copy UCSPI as long as you don't modify it. Of course, UCSPI
  47. is just a document laying out some ideas; it's not a real standard until
  48. enough people decide it's worth supporting. Please let me know what you
  49. think!
  50.  
  51. ---Dan Bernstein, brnstnd@nyu.edu
  52.  
  53. #! /bin/sh
  54. # This is a shell archive.  Remove anything before this line, then unpack
  55. # it by saving it into a file and typing "sh file".  To overwrite existing
  56. # files, type "sh file -c".  You can also feed this as standard input via
  57. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  58. # will see the following message at the end:
  59. #        "End of archive 1 (of 2)."
  60. # Contents:  BLURB DESIGN.npipe FILES FORMLETTER Makefile NPIPE README
  61. #   TCP UNDOM authuser.c authuser.h dupdup.c dupdup.h env.c env.h
  62. #   errno.h getopt.h hostname.c hostname.h malloc.h npipekiller.c
  63. #   numeric.c numeric.h numfiles.h portname.c portname.h tcpkiller.c
  64. #   testmain testresult testucspi undomclient.c undomkiller.c
  65. #   username.c username.h
  66. # Wrapped by brnstnd@kramden on Tue Jun 25 18:41:38 1991
  67. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  68. if test -f 'BLURB' -a "${1}" != "-c" ; then 
  69.   echo shar: Will not clobber existing file \"'BLURB'\"
  70. else
  71. echo shar: Extracting \"'BLURB'\" \(2255 characters\)
  72. sed "s/^X//" >'BLURB' <<'END_OF_FILE'
  73. XThis is clientserver 0.50, a set of three client-server suites
  74. Xsupporting different protocols with the same well-defined interface. Two
  75. Xof the suites support the TCP and UNDOM protocols for BSD systems; one
  76. Xsupports the NPIPE protocol for System V. (I'd love to hear from anyone
  77. Xwith a System V more modern than a 3B2: Does NPIPE run on your machine?)
  78. XAll obey the UCSPI (UNIX Client-Server Program Interface) standard, so
  79. Xyou can write programs that work exactly the same way on top of any of
  80. Xthe protocols. You can even use these communications facilities inside
  81. Xshell scripts.
  82. X
  83. XWhy do you want to use UCSPI-compliant communications tools? One
  84. Xadvantage is instant portability. By working with the client-server
  85. Xmodel given here, you instantly make your programs usable over the
  86. XInternet as well as on System V machines. Not only that, but your code
  87. Xwill work with any future communications tools designed to fit the
  88. Xstandard. Imagine supporting DECnet, AT&T's TLI, even Kerberos without
  89. Xlifting a finger! Another advantage is modularity: you can mix 'n' match
  90. Xprotocols and applications without worrying which program supports which
  91. Xprotocols. Finally, you can skip all those nasty steps of getting
  92. Xconnection information from the operating system. No matter what the
  93. Xprotocol is, UCSPI insists that you be given environment variables
  94. Xsaying who you're talking to.
  95. X
  96. XUCSPI also mandates an often ignored aspect of client-server
  97. Xcommunications: a standard way to kill the server. You don't have to go
  98. Xsearching through process lists or checking /etc/syslog.pid or sending
  99. XHUPS left and right. You stop a server the same way you started it. You
  100. Xmight set up a telnet daemon, for example, with this command:
  101. X
  102. X  tcpserver 0 telnet sh -c '/usr/etc/in.telnetd <&6 >&7 6<&- 7>&-' &
  103. X
  104. XHere 0 refers to the local machine, and telnet is a port. To kill the
  105. Xserver you just have to know the address:
  106. X
  107. X  tcpkiller 0 telnet
  108. X
  109. XThat's it.
  110. X
  111. XEverything here except the UCSPI-91 standard is in the public domain.
  112. XFeel free to copy UCSPI as long as you don't modify it. Of course, UCSPI
  113. Xis just a document laying out some ideas; it's not a real standard until
  114. Xenough people decide it's worth supporting. Please let me know what you
  115. Xthink!
  116. X
  117. X---Dan Bernstein, brnstnd@nyu.edu
  118. END_OF_FILE
  119. if test 2255 -ne `wc -c <'BLURB'`; then
  120.     echo shar: \"'BLURB'\" unpacked with wrong size!
  121. fi
  122. # end of 'BLURB'
  123. fi
  124. if test -f 'DESIGN.npipe' -a "${1}" != "-c" ; then 
  125.   echo shar: Will not clobber existing file \"'DESIGN.npipe'\"
  126. else
  127. echo shar: Extracting \"'DESIGN.npipe'\" \(950 characters\)
  128. sed "s/^X//" >'DESIGN.npipe' <<'END_OF_FILE'
  129. XHere's the idea: We create DIR/l.username/service, a mode-000 file. We
  130. Xcreate s.username, a mode-600 named pipe. We then change l.username to
  131. Xmode 600 and open s.username for reading. This blocks. Note that a
  132. Xclient may start writing before we start reading, or vice versa.
  133. X
  134. XMain loop: The client locks l.username. When it receives the lock, it
  135. Xopens s.username for writing, then creates DIR/s2c.pid and DIR/c2s.pid,
  136. Xthen writes pid and its username, then closes s.username, then opens
  137. Xs2c.pid for reading (this blocks) and c2s.pid for writing (this blocks).
  138. XWe read pid and the username, then close and unlink s.username. We then
  139. Xfork. In the parent, we then create s.username, a mode-600 named pipe,
  140. Xthen open s.username for reading; this is back to the original state. In
  141. Xthe child, we open s2c.pid for writing and c2s.pid for reading, then
  142. Xwrite a byte to s2c.pid. The client reads that byte, unlinks s2c.pid and
  143. Xc2s.pid, and unlocks l.username.
  144. END_OF_FILE
  145. if test 950 -ne `wc -c <'DESIGN.npipe'`; then
  146.     echo shar: \"'DESIGN.npipe'\" unpacked with wrong size!
  147. fi
  148. # end of 'DESIGN.npipe'
  149. fi
  150. if test -f 'FILES' -a "${1}" != "-c" ; then 
  151.   echo shar: Will not clobber existing file \"'FILES'\"
  152. else
  153. echo shar: Extracting \"'FILES'\" \(399 characters\)
  154. sed "s/^X//" >'FILES' <<'END_OF_FILE'
  155. XBLURB
  156. XREADME
  157. XFILES
  158. XFORMLETTER
  159. XUCSPI
  160. XTCP
  161. XUNDOM
  162. XNPIPE
  163. XDESIGN.npipe
  164. Xtestmain
  165. Xtestresult
  166. Xtestucspi
  167. XMakefile
  168. Xauthuser.h
  169. Xdupdup.h
  170. Xenv.h
  171. Xerrno.h
  172. Xgetopt.h
  173. Xhostname.h
  174. Xmalloc.h
  175. Xnumeric.h
  176. Xnumfiles.h
  177. Xportname.h
  178. Xusername.h
  179. Xauthuser.c
  180. Xdupdup.c
  181. Xenv.c
  182. Xhostname.c
  183. Xnpipeclient.c
  184. Xnpipeserver.c
  185. Xnpipekiller.c
  186. Xnumeric.c
  187. Xportname.c
  188. Xundomclient.c
  189. Xundomserver.c
  190. Xundomkiller.c
  191. Xusername.c
  192. Xtcpclient.c
  193. Xtcpserver.c
  194. Xtcpkiller.c
  195. END_OF_FILE
  196. if test 399 -ne `wc -c <'FILES'`; then
  197.     echo shar: \"'FILES'\" unpacked with wrong size!
  198. fi
  199. # end of 'FILES'
  200. fi
  201. if test -f 'FORMLETTER' -a "${1}" != "-c" ; then 
  202.   echo shar: Will not clobber existing file \"'FORMLETTER'\"
  203. else
  204. echo shar: Extracting \"'FORMLETTER'\" \(612 characters\)
  205. sed "s/^X//" >'FORMLETTER' <<'END_OF_FILE'
  206. XTo: brnstnd@nyu.edu
  207. XFrom: 
  208. XDate: 
  209. X
  210. XPackage: clientserver 0.50
  211. XObtained from (e.g., uunet.uu.net): 
  212. XObtained by (e.g., ftp): 
  213. X
  214. X1. Machine architecture (e.g., Sun 4/280): 
  215. X2. Operating system (e.g., SunOS 4.1): 
  216. X3. OS vendor (e.g., Sun): 
  217. X4. Does tcp work on your machine so far (yes/no/didn't try)? 
  218. X5. Does undom work on your machine so far (yes/no/didn't try)? 
  219. X6. Does npipe work on your machine so far (yes/no/didn't try)? 
  220. X7. What are CC and CCOPTS in your Makefile?
  221. X   CC=
  222. X   CCOPTS=
  223. X
  224. X8. Describe any problems you've had with clientserver.
  225. X
  226. X
  227. X9. Any further questions, comments, or suggestions?
  228. X
  229. X
  230. XYour name:
  231. END_OF_FILE
  232. if test 612 -ne `wc -c <'FORMLETTER'`; then
  233.     echo shar: \"'FORMLETTER'\" unpacked with wrong size!
  234. fi
  235. # end of 'FORMLETTER'
  236. fi
  237. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  238.   echo shar: Will not clobber existing file \"'Makefile'\"
  239. else
  240. echo shar: Extracting \"'Makefile'\" \(3109 characters\)
  241. sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  242. XCC=cc
  243. XCCOPTS=-g -DUNDOMDIR=\"/usr/local/etc/undom\" -DNPIPEDIR=\"/usr/local/etc/npipe\" -DSIGRET=int
  244. XMACHOPTS=
  245. XLIBS=-lresolv   # XXX: only necessary for tcp*
  246. X#
  247. X
  248. Xdefault: undom tcp npipe
  249. X
  250. Xundom: undomserver undomclient undomkiller
  251. X
  252. Xtcp: tcpserver tcpclient tcpkiller
  253. X
  254. Xnpipe: npipeserver npipeclient npipekiller
  255. X
  256. Xnpipekiller: npipekiller.o dupdup.o username.o numeric.o env.o
  257. X    $(CC) $(CCOPTS) $(MACHOPTS) -o npipekiller npipekiller.o dupdup.o username.o numeric.o env.o $(LIBS)
  258. X
  259. Xnpipeserver: npipeserver.o dupdup.o username.o numeric.o env.o
  260. X    $(CC) $(CCOPTS) $(MACHOPTS) -o npipeserver npipeserver.o dupdup.o username.o numeric.o env.o $(LIBS)
  261. X
  262. Xnpipeclient: npipeclient.o dupdup.o username.o numeric.o env.o
  263. X    $(CC) $(CCOPTS) $(MACHOPTS) -o npipeclient npipeclient.o dupdup.o username.o numeric.o env.o $(LIBS)
  264. X
  265. Xundomkiller: undomkiller.o dupdup.o username.o numeric.o env.o
  266. X    $(CC) $(CCOPTS) $(MACHOPTS) -o undomkiller undomkiller.o dupdup.o username.o numeric.o env.o $(LIBS)
  267. X
  268. Xundomserver: undomserver.o dupdup.o username.o numeric.o env.o
  269. X    $(CC) $(CCOPTS) $(MACHOPTS) -o undomserver undomserver.o dupdup.o username.o numeric.o env.o $(LIBS)
  270. X
  271. Xundomclient: undomclient.o dupdup.o username.o numeric.o env.o
  272. X    $(CC) $(CCOPTS) $(MACHOPTS) -o undomclient undomclient.o dupdup.o username.o numeric.o env.o $(LIBS)
  273. X
  274. Xtcpkiller: tcpkiller.o username.o numeric.o portname.o hostname.o env.o
  275. X    $(CC) $(CCOPTS) $(MACHOPTS) -o tcpkiller tcpkiller.o username.o numeric.o portname.o hostname.o env.o $(LIBS)
  276. X
  277. Xtcpserver: tcpserver.o dupdup.o username.o numeric.o authuser.o portname.o hostname.o env.o
  278. X    $(CC) $(CCOPTS) $(MACHOPTS) -o tcpserver tcpserver.o dupdup.o username.o numeric.o authuser.o portname.o hostname.o env.o $(LIBS)
  279. X
  280. Xtcpclient: tcpclient.o dupdup.o username.o numeric.o authuser.o portname.o hostname.o env.o
  281. X    $(CC) $(CCOPTS) $(MACHOPTS) -o tcpclient tcpclient.o dupdup.o username.o numeric.o authuser.o portname.o hostname.o env.o $(LIBS)
  282. X
  283. Xnpipekiller.o: npipekiller.c
  284. X    $(CC) $(CCOPTS) $(MACHOPTS) -c npipekiller.c
  285. X
  286. Xnpipeserver.o: npipeserver.c
  287. X    $(CC) $(CCOPTS) $(MACHOPTS) -c npipeserver.c
  288. X
  289. Xnpipeclient.o: npipeclient.c
  290. X    $(CC) $(CCOPTS) $(MACHOPTS) -c npipeclient.c
  291. X
  292. Xundomkiller.o: undomkiller.c
  293. X    $(CC) $(CCOPTS) $(MACHOPTS) -c undomkiller.c
  294. X
  295. Xundomserver.o: undomserver.c
  296. X    $(CC) $(CCOPTS) $(MACHOPTS) -c undomserver.c
  297. X
  298. Xundomclient.o: undomclient.c
  299. X    $(CC) $(CCOPTS) $(MACHOPTS) -c undomclient.c
  300. X
  301. Xtcpclient.o: tcpclient.c
  302. X    $(CC) $(CCOPTS) $(MACHOPTS) -c tcpclient.c
  303. X
  304. Xtcpkiller.o: tcpkiller.c
  305. X    $(CC) $(CCOPTS) $(MACHOPTS) -c tcpkiller.c
  306. X
  307. Xtcpserver.o: tcpserver.c
  308. X    $(CC) $(CCOPTS) $(MACHOPTS) -c tcpserver.c
  309. X
  310. Xdupdup.o: dupdup.c
  311. X    $(CC) $(CCOPTS) $(MACHOPTS) -c dupdup.c
  312. X
  313. Xusername.o: username.c
  314. X    $(CC) $(CCOPTS) $(MACHOPTS) -c username.c
  315. X
  316. Xportname.o: portname.c
  317. X    $(CC) $(CCOPTS) $(MACHOPTS) -c portname.c
  318. X
  319. Xhostname.o: hostname.c
  320. X    $(CC) $(CCOPTS) $(MACHOPTS) -c hostname.c
  321. X
  322. Xnumeric.o: numeric.c
  323. X    $(CC) $(CCOPTS) $(MACHOPTS) -c numeric.c
  324. X
  325. Xenv.o: env.c
  326. X    $(CC) $(CCOPTS) $(MACHOPTS) -c env.c
  327. X
  328. Xauthuser.o: authuser.c
  329. X    $(CC) $(CCOPTS) $(MACHOPTS) -c authuser.c
  330. X
  331. Xshar:
  332. X    shar `cat FILES` > ucspi.shar
  333. X    chmod 400 ucspi.shar
  334. END_OF_FILE
  335. if test 3109 -ne `wc -c <'Makefile'`; then
  336.     echo shar: \"'Makefile'\" unpacked with wrong size!
  337. fi
  338. # end of 'Makefile'
  339. fi
  340. if test -f 'NPIPE' -a "${1}" != "-c" ; then 
  341.   echo shar: Will not clobber existing file \"'NPIPE'\"
  342. else
  343. echo shar: Extracting \"'NPIPE'\" \(1377 characters\)
  344. sed "s/^X//" >'NPIPE' <<'END_OF_FILE'
  345. XNPIPE
  346. X6/23/91
  347. X
  348. X
  349. XThis document defines the NPIPE protocol for UCSPI programs. A NPIPE
  350. Xclient communicates with a NPIPE server on the same machine through a
  351. Xpair of named pipes.
  352. X
  353. X<address> consists of two arguments: <username> <service>. Neither
  354. Xargument can contain slashes, newlines, or periods. <username> must not
  355. Xcontain colons. Any other character understood by the local machine may
  356. Xappear. <username> is a username on the machine, and <service> is any
  357. Xtext chosen by <username> to represent a service.
  358. X
  359. X<clientaddress> is the username of the client user. <serveraddress> is
  360. X<username>:<service>. Both of these addresses are limited to 100
  361. Xcharacters.
  362. X
  363. XThe descriptors passed to <userprogram> refer to two independent
  364. Xunlinked named pipes (fifos). Descriptor 6 supports only reading and
  365. Xdescriptor 7 supports only writing. The semantics of these pipes are
  366. Xdefined by the local UNIX variant; no operations other than those
  367. Xapplicable to normal pipes may be assumed.
  368. X
  369. XIt must not be possible for one user to set up a service with a
  370. Xdifferent <username>. It must not be possible for a user to conceal or
  371. Xdisguise the username of a client.
  372. X
  373. XAll NPIPE programs have undefined behavior if any username involved
  374. Xshares a uid with a different username.
  375. X
  376. XPreferred executable names: npipeclient, npipeserver, npipekiller.
  377. X
  378. X
  379. XUCSPI Administrator
  380. XDaniel J. Bernstein, brnstnd@nyu.edu
  381. END_OF_FILE
  382. if test 1377 -ne `wc -c <'NPIPE'`; then
  383.     echo shar: \"'NPIPE'\" unpacked with wrong size!
  384. fi
  385. # end of 'NPIPE'
  386. fi
  387. if test -f 'README' -a "${1}" != "-c" ; then 
  388.   echo shar: Will not clobber existing file \"'README'\"
  389. else
  390. echo shar: Extracting \"'README'\" \(2539 characters\)
  391. sed "s/^X//" >'README' <<'END_OF_FILE'
  392. Xclientserver 0.50, 6/25/91, Daniel J. Bernstein, brnstnd@nyu.edu.
  393. XWatch alt.sources.d for patches, comp.sources.unix for the next version.
  394. XLatest version inside stealth.acf.nyu.edu:pub/hier/clientserver/.
  395. X
  396. XThis has been extensively tested under SunOS 4.0.3, Ultrix 4.1, BSD 4.3,
  397. Xand the latest pre-BSD 4.4, and it appears to work on several other
  398. Xsystems. Under gcc you MUST define -fwritable-strings; sorry, old habits
  399. Xdie hard.
  400. X
  401. XModify UNDOMDIR and NPIPEDIR in Makefile for your system. Make some uid,
  402. Xsay undom, with access to UNDOMDIR; make UNDOMDIR mode 700 ownder undom.
  403. XMake some uid, say npipe, with access to NPIPEDIR; make NPIPEDIR mode
  404. X700 owner npipe. Make sure LIBS makes sense for you: most BSD systems
  405. Xneed -lresolv to use the resolver, and if you don't have getopt you'll
  406. Xhave to pick it up and put it into LIBS. That's it for configuration.
  407. X
  408. XMake. On BSD systems without named pipes, you should make only tcp and
  409. Xundom. On System V systems without sockets, you should make npipe. (I
  410. Xhave absolutely no idea whether npipe actually works on any modern
  411. XSystem V machines.) Under SunOS and Ultrix, make everything.
  412. X
  413. XTo test the programs, run testmain in this directory with appropriate
  414. Xarguments. Examples:
  415. X
  416. X  ./testmain NPIPE npipe <yourusername> blah
  417. X  ./testmain UNDOM undom <yourusername> foop
  418. X  ./testmain TCP tcp 0 <randomportnumber>
  419. X
  420. XThe 0 in the last line is an abbreviation for the local host. testmain
  421. Xshould say ``Everything compares okay''; if not, don't panic, because
  422. Xthe test code can report false alarms. (It uses sleep(1) for
  423. Xsynchronization.) Just run it again. To see what's going on, run
  424. Xtestucspi in place of testmain.
  425. X
  426. XInstall tcp{client,server,killer} somewhere, NOT setuid. Install
  427. Xundom{client,server,killer} somewhere, owner undom, mode 4755. Install
  428. Xnpipe{client,server,killer} somewhere, owner npipe, mode 4755. That's
  429. Xit. You might want to have your rc.local remove anything in UNDOMDIR or
  430. XNPIPEDIR.
  431. X
  432. X*PLEASE* fill out FORMLETTER and send it to me if you had problems.
  433. X*PLEASE* fill out FORMLETTER and send it to me if everything worked!
  434. XThanks for being a good sport.
  435. X
  436. XThe best documentation available at the moment is UCSPI and its
  437. Xassociated documents (TCP, UNDOM, NPIPE). Look at testucspi for an
  438. Xexample of how to communicate between independent processes with UCSPI.
  439. X
  440. X
  441. XXXX: handle EINTR better in undomserver.c and npipe*.c
  442. XXXX: restore signals properly?
  443. XXXX: fix all the exit codes
  444. XXXX: write man pages!
  445. XXXX: write a real README! and BLURB
  446. XXXX: provide semi-automatic reboot cleanup stuff?
  447. END_OF_FILE
  448. if test 2539 -ne `wc -c <'README'`; then
  449.     echo shar: \"'README'\" unpacked with wrong size!
  450. fi
  451. # end of 'README'
  452. fi
  453. if test -f 'TCP' -a "${1}" != "-c" ; then 
  454.   echo shar: Will not clobber existing file \"'TCP'\"
  455. else
  456. echo shar: Extracting \"'TCP'\" \(2835 characters\)
  457. sed "s/^X//" >'TCP' <<'END_OF_FILE'
  458. XTCP
  459. X6/19/91
  460. X
  461. X
  462. XThis document defines the TCP protocol for UCSPI programs. A TCP client
  463. Xcommunicates with a TCP server, on the same machine or on a different
  464. Xmachine, via the TCP/IP protocol through an Internet-domain socket.
  465. X
  466. X<address> consists of two arguments: <hostname> <port>. <hostname> may
  467. Xeither be a dotted IP address (such as 128.122.128.2) or a name which,
  468. Xon the local machine, somehow represents such an address. (For example,
  469. Xdomain names understood by DNS or by a local NIC-style host table might
  470. Xbe valid <hostname>s.) <hostname> may also be the single character 0,
  471. Xreferring to the local machine. <port> may either be a numeric TCP port
  472. Xnumber (such as 25, the standard SMTP port) or a name which, on the
  473. Xlocal machine, somehow represents a port number. Any character may
  474. Xappear in <hostname> or <port>.
  475. X
  476. X<clientaddress> and <serveraddress> share a single format:
  477. X<username>@<hostnumber>(<hostname>):<port>. <username> is a username on
  478. Xthe machine in question: inside TCPLOCAL, <username> is the real
  479. Xusername of the process, and inside TCPREMOTE, <username> is the
  480. Xusername returned by the other machine via RFC 931, or blank if the
  481. Xother machine does not support RFC 931. The client and server must take
  482. Xa -R option to turn off RFC 931 checking, and -r to turn it back on.
  483. XUnder -R, <username> will always be blank inside TCPREMOTE. <hostnumber>
  484. Xis the IP address of the communicating host. <hostname> is either that
  485. Xaddress or, if available, a name representing that address. <port> is
  486. Xthe relevant TCP port.
  487. X
  488. XNote that this address format is ambiguous, except in <port>. <hostname>
  489. Xdepends on local name lookup conventions, <username> may be blank, and
  490. X<hostnumber> might refer to the same machine through special numbers
  491. Xsuch as 127.0.0.1 and 0.0.0.0. Application programs which use
  492. X<clientaddress> and <serveraddress> should keep these caveats in mind.
  493. X
  494. XThe descriptors passed to <userprogram> refer to an INET-domain stream
  495. Xsocket, dup()ed from a single connect() or accept(). The semantics of
  496. Xthis socket are defined by the local UNIX variant, but it is expected
  497. Xthat it will support out-of-band data as in BSD systems past 4.2,
  498. Xsubject to the restrictions of RFC 1122 and RFC 1123.
  499. X
  500. XIf <port> is 0, the server must choose an available port number or
  501. Xreport an error. The client must take a -p <locport> option to set a
  502. Xdesired TCP port on the local side of the connection; if it cannot
  503. Xsatisfy this request, it must report an error.
  504. X
  505. XThe killer must not work upon a server running on a different machine.
  506. XThe killer and the server may communicate through files stored in the
  507. Xhome directory of the invoking user, as specified by environment
  508. Xvariable TCPHOME, or HOME if TCPHOME is not set.
  509. X
  510. XPreferred executable names: tcpclient, tcpserver, tcpkiller.
  511. X
  512. X
  513. XUCSPI Administrator
  514. XDaniel J. Bernstein, brnstnd@nyu.edu
  515. END_OF_FILE
  516. if test 2835 -ne `wc -c <'TCP'`; then
  517.     echo shar: \"'TCP'\" unpacked with wrong size!
  518. fi
  519. # end of 'TCP'
  520. fi
  521. if test -f 'UNDOM' -a "${1}" != "-c" ; then 
  522.   echo shar: Will not clobber existing file \"'UNDOM'\"
  523. else
  524. echo shar: Extracting \"'UNDOM'\" \(1409 characters\)
  525. sed "s/^X//" >'UNDOM' <<'END_OF_FILE'
  526. XUNDOM
  527. X6/16/91
  528. X
  529. X
  530. XThis document defines the UNDOM protocol for UCSPI programs. A UNDOM
  531. Xclient communicates with a UNDOM server on the same machine through a
  532. XUNIX-domain socket.
  533. X
  534. X<address> consists of two arguments: <username> <service>. Neither
  535. Xargument can contain slashes, newlines, or periods. <username> must not
  536. Xcontain colons. Any other character understood by the local machine may
  537. Xappear. <username> is a username on the machine, and <service> is any
  538. Xtext chosen by <username> to represent a service.
  539. X
  540. X<clientaddress> is the username of the client user. <serveraddress> is
  541. X<username>:<service>. Both of these addresses are limited to 100
  542. Xcharacters.
  543. X
  544. XThe descriptors passed to <userprogram> refer to a UNIX-domain stream
  545. Xsocket whose name is a function of <username> and <service>; they are
  546. Xdup()ed from a single connect() or accept(). The semantics of this
  547. Xsocket are defined by the local UNIX variant, but it is expected that it
  548. Xwill support file descriptor passing as in BSD systems past 4.2.
  549. X
  550. XIt must not be possible for one user to set up a service with a
  551. Xdifferent <username>. It must not be possible for a user to conceal or
  552. Xdisguise the username of a client.
  553. X
  554. XAll UNDOM programs have undefined behavior if any username involved
  555. Xshares a uid with a different username.
  556. X
  557. XPreferred executable names: undomclient, undomserver, undomkiller.
  558. X
  559. X
  560. XUCSPI Administrator
  561. XDaniel J. Bernstein, brnstnd@nyu.edu
  562. END_OF_FILE
  563. if test 1409 -ne `wc -c <'UNDOM'`; then
  564.     echo shar: \"'UNDOM'\" unpacked with wrong size!
  565. fi
  566. # end of 'UNDOM'
  567. fi
  568. if test -f 'authuser.c' -a "${1}" != "-c" ; then 
  569.   echo shar: Will not clobber existing file \"'authuser.c'\"
  570. else
  571. echo shar: Extracting \"'authuser.c'\" \(3622 characters\)
  572. sed "s/^X//" >'authuser.c' <<'END_OF_FILE'
  573. X/*
  574. X5/6/91 DJB baseline authuser 3.1. Public domain.
  575. X*/
  576. X
  577. X#include <stdio.h>
  578. X#include <sys/types.h>
  579. X#include <sys/socket.h>
  580. X#include <netinet/in.h>
  581. X#include <arpa/inet.h>
  582. X#include <netdb.h>
  583. X#include <errno.h>
  584. X#include <ctype.h>
  585. Xextern int errno;
  586. X#include "authuser.h"
  587. X
  588. Xunsigned short auth_tcpport = 113;
  589. X
  590. X#define SIZ 500 /* various buffers */
  591. X
  592. Xstatic int usercmp(u,v)
  593. Xregister char *u;
  594. Xregister char *v;
  595. X{
  596. X /* is it correct to consider Foo and fOo the same user? yes */
  597. X /* but the function of this routine may change later */
  598. X while (*u && *v)
  599. X   if (tolower(*u) != tolower(*v))
  600. X     return tolower(*u) - tolower(*v);
  601. X   else
  602. X     ++u,++v;
  603. X return *u || *v;
  604. X}
  605. X
  606. Xstatic char authline[SIZ];
  607. X
  608. Xchar *auth_xline(user,fd,in)
  609. Xregister char *user; /* the supposed name of the user, NULL if unknown */
  610. Xregister int fd; /* the file descriptor of the connection */
  611. Xregister unsigned long *in;
  612. X{
  613. X unsigned short local;
  614. X unsigned short remote;
  615. X register char *ruser;
  616. X
  617. X if (auth_fd(fd,in,&local,&remote) == -1)
  618. X   return 0;
  619. X ruser = auth_tcpuser(*in,local,remote);
  620. X if (!ruser)
  621. X   return 0;
  622. X if (!user)
  623. X   user = ruser; /* forces X-Auth-User */
  624. X (void) sprintf(authline,
  625. X     (usercmp(ruser,user) ? "X-Forgery-By: %s" : "X-Auth-User: %s"),
  626. X     ruser);
  627. X return authline;
  628. X}
  629. X
  630. Xint auth_fd(fd,in,local,remote)
  631. Xregister int fd;
  632. Xregister unsigned long *in;
  633. Xregister unsigned short *local;
  634. Xregister unsigned short *remote;
  635. X{
  636. X struct sockaddr_in sa;
  637. X int dummy;
  638. X
  639. X dummy = sizeof(sa);
  640. X if (getsockname(fd,&sa,&dummy) == -1)
  641. X   return -1;
  642. X if (sa.sin_family != AF_INET)
  643. X  {
  644. X   errno = EAFNOSUPPORT;
  645. X   return -1;
  646. X  }
  647. X *local = ntohs(sa.sin_port);
  648. X dummy = sizeof(sa);
  649. X if (getpeername(fd,&sa,&dummy) == -1)
  650. X   return -1;
  651. X *remote = ntohs(sa.sin_port);
  652. X *in = sa.sin_addr.s_addr;
  653. X return 0;
  654. X}
  655. X
  656. Xstatic char ruser[SIZ];
  657. Xstatic char realbuf[SIZ];
  658. Xstatic char *buf;
  659. X
  660. Xchar *auth_tcpuser(in,local,remote)
  661. Xregister unsigned long in;
  662. Xregister unsigned short local;
  663. Xregister unsigned short remote;
  664. X{
  665. X struct sockaddr_in sa;
  666. X register int s;
  667. X register int buflen;
  668. X register int w;
  669. X register int saveerrno;
  670. X char ch;
  671. X unsigned short rlocal;
  672. X unsigned short rremote;
  673. X
  674. X if ((s = socket(AF_INET,SOCK_STREAM,0)) == -1)
  675. X   return 0;
  676. X sa.sin_family = AF_INET;
  677. X sa.sin_port = htons(auth_tcpport);
  678. X sa.sin_addr.s_addr = in;
  679. X if (connect(s,&sa,sizeof(sa)) == -1)
  680. X  {
  681. X   saveerrno = errno;
  682. X   (void) close(s);
  683. X   errno = saveerrno;
  684. X   return 0;
  685. X  }
  686. X
  687. X buf = realbuf;
  688. X (void) sprintf(buf,"%u , %u\r\n",(unsigned int) remote,(unsigned int) local);
  689. X /* note the reversed order---the example in the RFC is misleading */
  690. X buflen = strlen(buf);
  691. X while ((w = write(s,buf,buflen)) < buflen)
  692. X   if (w == -1) /* should we worry about 0 as well? */
  693. X    {
  694. X     saveerrno = errno;
  695. X     (void) close(s);
  696. X     errno = saveerrno;
  697. X     return 0;
  698. X    }
  699. X   else
  700. X    {
  701. X     buf += w;
  702. X     buflen -= w;
  703. X    }
  704. X buf = realbuf;
  705. X while ((w = read(s,&ch,1)) == 1)
  706. X  {
  707. X   *buf = ch;
  708. X   if ((ch != ' ') && (ch != '\t') && (ch != '\r'))
  709. X     ++buf;
  710. X   if ((buf - realbuf == sizeof(realbuf) - 1) || (ch == '\n'))
  711. X     break;
  712. X  }
  713. X if (w == -1)
  714. X  {
  715. X   saveerrno = errno;
  716. X   (void) close(s);
  717. X   errno = saveerrno;
  718. X   return 0;
  719. X  }
  720. X *buf = '\0';
  721. X
  722. X if (sscanf(realbuf,"%hd,%hd: USERID :%*[^:]:%s",&rremote,&rlocal,ruser) < 3)
  723. X  {
  724. X   (void) close(s);
  725. X   errno = EIO;
  726. X   /* makes sense, right? well, not when USERID failed to match ERROR */
  727. X   /* but there's no good error to return in that case */
  728. X   return 0;
  729. X  }
  730. X if ((remote != rremote) || (local != rlocal))
  731. X  {
  732. X   (void) close(s);
  733. X   errno = EIO;
  734. X   return 0;
  735. X  }
  736. X /* XXX: we're not going to do any backslash processing */
  737. X (void) close(s);
  738. X return ruser;
  739. X}
  740. END_OF_FILE
  741. if test 3622 -ne `wc -c <'authuser.c'`; then
  742.     echo shar: \"'authuser.c'\" unpacked with wrong size!
  743. fi
  744. # end of 'authuser.c'
  745. fi
  746. if test -f 'authuser.h' -a "${1}" != "-c" ; then 
  747.   echo shar: Will not clobber existing file \"'authuser.h'\"
  748. else
  749. echo shar: Extracting \"'authuser.h'\" \(161 characters\)
  750. sed "s/^X//" >'authuser.h' <<'END_OF_FILE'
  751. X#ifndef AUTHUSER_H
  752. X#define AUTHUSER_H
  753. X
  754. Xextern unsigned short auth_tcpport;
  755. Xextern char *auth_xline();
  756. Xextern int auth_fd();
  757. Xextern char *auth_tcpuser();
  758. X
  759. X#endif
  760. END_OF_FILE
  761. if test 161 -ne `wc -c <'authuser.h'`; then
  762.     echo shar: \"'authuser.h'\" unpacked with wrong size!
  763. fi
  764. # end of 'authuser.h'
  765. fi
  766. if test -f 'dupdup.c' -a "${1}" != "-c" ; then 
  767.   echo shar: Will not clobber existing file \"'dupdup.c'\"
  768. else
  769. echo shar: Extracting \"'dupdup.c'\" \(2174 characters\)
  770. sed "s/^X//" >'dupdup.c' <<'END_OF_FILE'
  771. X/* Public domain. */
  772. X
  773. X#include <fcntl.h>
  774. X#include "dupdup.h"
  775. X
  776. Xstatic int dupit(old,new)
  777. Xint old;
  778. Xint new;
  779. X{
  780. X/* What follows is roughly equivalent to the following:
  781. X      if (dup2(old,new) == -1) return -1; close(old); return 0;
  782. X   Differences: errno can be different; this works under System V;
  783. X   this is about twice as slow.
  784. X*/
  785. X if (old == new) /* shouldn't happen */
  786. X   return 0;
  787. X if (fcntl(old,F_GETFL,0) == -1) /* old is bad */
  788. X   return -1;
  789. X close(new); /* XXX: check error codes? */
  790. X if (fcntl(old,F_DUPFD,new) == -1) /* can't dup */
  791. X   return -1;
  792. X close(old); /*XXX*/
  793. X return 0;
  794. X}
  795. X
  796. Xint dupdup(d,n)
  797. Xint *d;
  798. Xint n;
  799. X{
  800. X int i;
  801. X int j;
  802. X int k;
  803. X int l;
  804. X
  805. X /* Descriptor i will become descriptor d[i], if d[i] != -1. */
  806. X /* The original descriptor d[i] will disappear. */
  807. X /* The array d[i] may be mangled freely. */
  808. X /* n is the size of d[]. */
  809. X /* No guarantees if i and j both become k. */
  810. X /* errno is set properly on a -1 return. */
  811. X
  812. X for (i = 0;i < n;++i)
  813. X   if (d[i] != -1)
  814. X    {
  815. X     for (j = d[i];(j != -1) && (j != i) && (j != d[j]);j = d[j])
  816. X       ;
  817. X     if ((j == -1) || (j == d[j]))
  818. X       if (j == i)
  819. X     ; /* self-loop */
  820. X       else
  821. X    { /* no cycle */
  822. X     if (j != -1)
  823. X       d[j] = -1;
  824. X     if (d[d[i]] == -1) /*XXX*/
  825. X      {
  826. X       if (dupit(i,d[i]) == -1)
  827. X         return -1;
  828. X       d[i] = -1;
  829. X      }
  830. X     else
  831. X      {
  832. X       k = i; j = d[i];
  833. X       do
  834. X        {
  835. X         l = d[j]; d[j] = k; k = j; j = l;
  836. X        }
  837. X       while (j != -1);
  838. X       for (j = k;j != i;j = k)
  839. X        {
  840. X         if (dupit(d[j],j) == -1)
  841. X           return -1;
  842. X         k = d[j];
  843. X         d[j] = -1;
  844. X        }
  845. X       d[i] = -1;
  846. X      }
  847. X    }
  848. X     else
  849. X      { /* cycle */
  850. X       if (dupit(i,n) == -1)
  851. X     return -1;
  852. X       if (d[d[i]] == i) /*XXX*/
  853. X    {
  854. X     if (dupit(d[i],i) == -1)
  855. X       return -1;
  856. X     if (dupit(n,d[i]) == -1)
  857. X       return -1;
  858. X     d[d[i]] = -1;
  859. X     d[i] = -1;
  860. X    }
  861. X       else
  862. X        {
  863. X         k = i; j = d[i];
  864. X         do
  865. X          {
  866. X           l = d[j]; d[j] = k; k = j; j = l;
  867. X          }
  868. X         while (j != i);
  869. X         for (j = k;j != i;j = k)
  870. X          {
  871. X       if (dupit(d[j],j) == -1)
  872. X         return -1;
  873. X       k = d[j];
  874. X           d[j] = -1;
  875. X          }
  876. X         d[i] = -1;
  877. X     if (dupit(n,k) == -1)
  878. X       return -1;
  879. X        }
  880. X      }
  881. X    }
  882. X return 0;
  883. X}
  884. END_OF_FILE
  885. if test 2174 -ne `wc -c <'dupdup.c'`; then
  886.     echo shar: \"'dupdup.c'\" unpacked with wrong size!
  887. fi
  888. # end of 'dupdup.c'
  889. fi
  890. if test -f 'dupdup.h' -a "${1}" != "-c" ; then 
  891.   echo shar: Will not clobber existing file \"'dupdup.h'\"
  892. else
  893. echo shar: Extracting \"'dupdup.h'\" \(64 characters\)
  894. sed "s/^X//" >'dupdup.h' <<'END_OF_FILE'
  895. X#ifndef DUPDUP_H
  896. X#define DUPDUP_H
  897. X
  898. Xextern int dupdup();
  899. X
  900. X#endif
  901. END_OF_FILE
  902. if test 64 -ne `wc -c <'dupdup.h'`; then
  903.     echo shar: \"'dupdup.h'\" unpacked with wrong size!
  904. fi
  905. # end of 'dupdup.h'
  906. fi
  907. if test -f 'env.c' -a "${1}" != "-c" ; then 
  908.   echo shar: Will not clobber existing file \"'env.c'\"
  909. else
  910. echo shar: Extracting \"'env.c'\" \(2157 characters\)
  911. sed "s/^X//" >'env.c' <<'END_OF_FILE'
  912. X/* Public domain. */
  913. X
  914. X/*
  915. XThese are portable versions of putenv(). env_put("FOO=BAR") is like
  916. XFOO=BAR inside sh; env_unset("FOO") unsets any variable FOO. env_init()
  917. Xis optional initialization. env_get is just like getenv. Of course, all
  918. Xchanges are tracked through environ, so execvp() and friends will pick
  919. Xup the new variables.
  920. X*/
  921. X
  922. X/* uses environ, malloc, free, strlen, strncmp */
  923. X
  924. X#include "env.h"
  925. X#include "malloc.h"
  926. X
  927. Xextern char **environ;
  928. Xstatic int init = 0;
  929. Xstatic int numenv;
  930. Xstatic int allocenv;
  931. X
  932. Xextern char *env_get(s)
  933. Xchar *s;
  934. X{
  935. X int i;
  936. X int slen;
  937. X
  938. X if (!init)
  939. X   if (env_init())
  940. X     return 0;
  941. X
  942. X slen = strlen(s);
  943. X for (i = 0;i < numenv;++i)
  944. X   if ((!strncmp(s,environ[i],slen)) && (environ[i][slen] == '='))
  945. X     return environ[i] + slen + 1;
  946. X return 0;
  947. X}
  948. X
  949. Xextern int env_unset(s)
  950. Xchar *s;
  951. X{
  952. X int i;
  953. X int slen;
  954. X 
  955. X if (!init)
  956. X   if (env_init())
  957. X     return -1;
  958. X slen = strlen(s);
  959. X for (i = 0;i < numenv;++i)
  960. X   if ((!strncmp(s,environ[i],slen)) && (environ[i][slen] == '='))
  961. X    {
  962. X     if (i < --numenv)
  963. X       environ[i] = environ[numenv];
  964. X     environ[numenv] = 0;
  965. X    }
  966. X return 0;
  967. X}
  968. X
  969. Xstatic int env_realloc()
  970. X{
  971. X char **envp;
  972. X
  973. X allocenv = numenv + 30;
  974. X envp = environ;
  975. X environ = (char **) malloc(allocenv * (int) sizeof(char *));
  976. X if (!environ)
  977. X  {
  978. X   environ = envp;
  979. X   allocenv = numenv;
  980. X   return -1;
  981. X  }
  982. X numenv = 0;
  983. X while (*envp)
  984. X  {
  985. X   environ[numenv] = *envp;
  986. X   ++numenv;
  987. X   ++envp;
  988. X  }
  989. X environ[numenv] = 0;
  990. X free((char *) (envp - numenv));
  991. X return 0;
  992. X}
  993. X
  994. Xstatic int env_add(s)
  995. Xchar *s;
  996. X{
  997. X char *t;
  998. X for (t = s;*t;++t)
  999. X   if (*t == '=')
  1000. X     break;
  1001. X if (*t)
  1002. X  {
  1003. X   *t = 0;
  1004. X   if (env_unset(s))
  1005. X     return -1;
  1006. X   *t = '=';
  1007. X  }
  1008. X if (numenv == allocenv)
  1009. X   if (env_realloc())
  1010. X     return -1;
  1011. X environ[numenv] = s;
  1012. X ++numenv;
  1013. X environ[numenv] = 0;
  1014. X return 0;
  1015. X}
  1016. X
  1017. Xint env_init()
  1018. X{
  1019. X char **envp;
  1020. X
  1021. X numenv = 0;
  1022. X allocenv = 0;
  1023. X envp = environ;
  1024. X environ = (char **) malloc(sizeof(char *));
  1025. X if (!environ)
  1026. X  {
  1027. X   environ = envp;
  1028. X   return -1;
  1029. X  }
  1030. X init = 1;
  1031. X while (*envp)
  1032. X  {
  1033. X   if (env_add(*envp))
  1034. X     return -1;
  1035. X   ++envp;
  1036. X  }
  1037. X return 0;
  1038. X}
  1039. X
  1040. Xint env_put(s)
  1041. Xchar *s;
  1042. X{
  1043. X if (!init)
  1044. X   if (env_init())
  1045. X     return -1;
  1046. X return env_add(s);
  1047. X}
  1048. END_OF_FILE
  1049. if test 2157 -ne `wc -c <'env.c'`; then
  1050.     echo shar: \"'env.c'\" unpacked with wrong size!
  1051. fi
  1052. # end of 'env.c'
  1053. fi
  1054. if test -f 'env.h' -a "${1}" != "-c" ; then 
  1055.   echo shar: Will not clobber existing file \"'env.h'\"
  1056. else
  1057. echo shar: Extracting \"'env.h'\" \(153 characters\)
  1058. sed "s/^X//" >'env.h' <<'END_OF_FILE'
  1059. X#ifndef ENV_H
  1060. X#define ENV_H
  1061. X
  1062. Xextern int env_init();
  1063. Xextern int env_put();
  1064. Xextern int env_unset();
  1065. Xextern char *env_get(); /* for completeness */
  1066. X
  1067. X#endif
  1068. END_OF_FILE
  1069. if test 153 -ne `wc -c <'env.h'`; then
  1070.     echo shar: \"'env.h'\" unpacked with wrong size!
  1071. fi
  1072. # end of 'env.h'
  1073. fi
  1074. if test -f 'errno.h' -a "${1}" != "-c" ; then 
  1075.   echo shar: Will not clobber existing file \"'errno.h'\"
  1076. else
  1077. echo shar: Extracting \"'errno.h'\" \(78 characters\)
  1078. sed "s/^X//" >'errno.h' <<'END_OF_FILE'
  1079. X#ifndef ERRNO_H
  1080. X#define ERRNO_H
  1081. X
  1082. X#include <errno.h>
  1083. Xextern int errno;
  1084. X
  1085. X#endif
  1086. END_OF_FILE
  1087. if test 78 -ne `wc -c <'errno.h'`; then
  1088.     echo shar: \"'errno.h'\" unpacked with wrong size!
  1089. fi
  1090. # end of 'errno.h'
  1091. fi
  1092. if test -f 'getopt.h' -a "${1}" != "-c" ; then 
  1093.   echo shar: Will not clobber existing file \"'getopt.h'\"
  1094. else
  1095. echo shar: Extracting \"'getopt.h'\" \(298 characters\)
  1096. sed "s/^X//" >'getopt.h' <<'END_OF_FILE'
  1097. X#ifndef GETOPT_H
  1098. X#define GETOPT_H
  1099. X
  1100. X/* I'm trusting the user to acquire a getopt library, rather than
  1101. Xproviding one myself. This is probably a mistake. */
  1102. X
  1103. X/* The following should be in /usr/include/getopt.h but often aren't. */
  1104. X
  1105. Xextern int getopt();
  1106. Xextern char *optarg;
  1107. Xextern int optind;
  1108. X
  1109. X#endif
  1110. END_OF_FILE
  1111. if test 298 -ne `wc -c <'getopt.h'`; then
  1112.     echo shar: \"'getopt.h'\" unpacked with wrong size!
  1113. fi
  1114. # end of 'getopt.h'
  1115. fi
  1116. if test -f 'hostname.c' -a "${1}" != "-c" ; then 
  1117.   echo shar: Will not clobber existing file \"'hostname.c'\"
  1118. else
  1119. echo shar: Extracting \"'hostname.c'\" \(1191 characters\)
  1120. sed "s/^X//" >'hostname.c' <<'END_OF_FILE'
  1121. X/* History:
  1122. X5/1/91 DJB baseline public domain. todo: cache hosts.
  1123. X*/
  1124. X
  1125. X#include <sys/types.h>
  1126. X#include <sys/socket.h>
  1127. X#include <netdb.h>
  1128. X#include <netinet/in.h>
  1129. X#include "hostname.h"
  1130. X#include "numeric.h"
  1131. X
  1132. Xint inaddr2hostname(inaddr,hostname)
  1133. Xstruct in_addr inaddr;
  1134. Xchar **hostname;
  1135. X{
  1136. X struct hostent *he;
  1137. X static char hn[30];
  1138. X unsigned char *x;
  1139. X
  1140. X if (he = gethostbyaddr(&inaddr,sizeof(inaddr),AF_INET))
  1141. X  {
  1142. X   *hostname = he->h_name;
  1143. X   return 0;
  1144. X  }
  1145. X x = (unsigned char *) &inaddr;
  1146. X sprintf(hn,"%d.%d.%d.%d"
  1147. X   ,(int) (unsigned int) x[0],(int) (unsigned int) x[1]
  1148. X   ,(int) (unsigned int) x[2],(int) (unsigned int) x[3]
  1149. X  );
  1150. X *hostname = hn;
  1151. X return 1;
  1152. X}
  1153. X
  1154. Xint hostname2inaddr(hostname,inaddr)
  1155. Xchar *hostname;
  1156. Xstruct in_addr *inaddr;
  1157. X{
  1158. X struct hostent *he;
  1159. X char *x;
  1160. X int h1; int h2; int h3; int h4;
  1161. X
  1162. X x = (char *) inaddr;
  1163. X if (numericdots(hostname) == 3)
  1164. X   if (sscanf(hostname,"%d.%d.%d.%d",&h1,&h2,&h3,&h4) == 4)
  1165. X    {
  1166. X     x[0] = h1; x[1] = h2; x[2] = h3; x[3] = h4;
  1167. X     return 1;
  1168. X    }
  1169. X /* could use inet_ntoa here */
  1170. X he = gethostbyname(hostname);
  1171. X if (!he)
  1172. X   return -1; /*XXX*/
  1173. X x[0] = he->h_addr[0];
  1174. X x[1] = he->h_addr[1];
  1175. X x[2] = he->h_addr[2];
  1176. X x[3] = he->h_addr[3];
  1177. X return 0;
  1178. X}
  1179. END_OF_FILE
  1180. if test 1191 -ne `wc -c <'hostname.c'`; then
  1181.     echo shar: \"'hostname.c'\" unpacked with wrong size!
  1182. fi
  1183. # end of 'hostname.c'
  1184. fi
  1185. if test -f 'hostname.h' -a "${1}" != "-c" ; then 
  1186.   echo shar: Will not clobber existing file \"'hostname.h'\"
  1187. else
  1188. echo shar: Extracting \"'hostname.h'\" \(107 characters\)
  1189. sed "s/^X//" >'hostname.h' <<'END_OF_FILE'
  1190. X#ifndef HOSTNAME_H
  1191. X#define HOSTNAME_H
  1192. X
  1193. Xextern int inaddr2hostname();
  1194. Xextern int hostname2inaddr();
  1195. X
  1196. X#endif
  1197. END_OF_FILE
  1198. if test 107 -ne `wc -c <'hostname.h'`; then
  1199.     echo shar: \"'hostname.h'\" unpacked with wrong size!
  1200. fi
  1201. # end of 'hostname.h'
  1202. fi
  1203. if test -f 'malloc.h' -a "${1}" != "-c" ; then 
  1204.   echo shar: Will not clobber existing file \"'malloc.h'\"
  1205. else
  1206. echo shar: Extracting \"'malloc.h'\" \(66 characters\)
  1207. sed "s/^X//" >'malloc.h' <<'END_OF_FILE'
  1208. X#ifndef MALLOC_H
  1209. X#define MALLOC_H
  1210. X
  1211. Xextern char *malloc();
  1212. X
  1213. X#endif
  1214. END_OF_FILE
  1215. if test 66 -ne `wc -c <'malloc.h'`; then
  1216.     echo shar: \"'malloc.h'\" unpacked with wrong size!
  1217. fi
  1218. # end of 'malloc.h'
  1219. fi
  1220. if test -f 'npipekiller.c' -a "${1}" != "-c" ; then 
  1221.   echo shar: Will not clobber existing file \"'npipekiller.c'\"
  1222. else
  1223. echo shar: Extracting \"'npipekiller.c'\" \(3207 characters\)
  1224. sed "s/^X//" >'npipekiller.c' <<'END_OF_FILE'
  1225. X/* Public domain. */
  1226. X
  1227. X#include <stdio.h>
  1228. X#include <sys/types.h>
  1229. X#include <sys/file.h>
  1230. X#include <signal.h>
  1231. X#include <fcntl.h>
  1232. X#include "dupdup.h"
  1233. X#include "malloc.h"
  1234. X#include "errno.h"
  1235. X#include "username.h"
  1236. X#include "env.h"
  1237. X#include "getopt.h"
  1238. X#include "numfiles.h"
  1239. X
  1240. X#ifndef F_LOCK
  1241. X#define F_LOCK 1
  1242. X#endif
  1243. X#ifndef O_RDONLY
  1244. X#define O_RDONLY 0
  1245. X#endif
  1246. X#ifndef O_WRONLY
  1247. X#define O_WRONLY 1
  1248. X#endif
  1249. X#ifndef O_RDWR
  1250. X#define O_RDWR 2
  1251. X#endif
  1252. X
  1253. Xstatic int flagverbose = 1;
  1254. X
  1255. Xstatic char errbuf[500];
  1256. Xvoid die(n,s) int n; char *s;
  1257. X{ if (flagverbose) fprintf(stderr,"npipekiller: fatal: %s\n",s); exit(n); }
  1258. Xvoid dies(n,s,t) int n; char *s; char *t;
  1259. X{ if (flagverbose) fprintf(stderr,"npipekiller: fatal: %s%s\n",s,t); exit(n); }
  1260. Xvoid diep(n,s) int n; char *s;
  1261. X{ if (flagverbose) sprintf(errbuf,"npipekiller: fatal: %s",s); perror(errbuf); exit(n); }
  1262. Xvoid warnp(s) char *s;
  1263. X{ if (flagverbose) sprintf(errbuf,"npipekiller: warning: %s",s); perror(errbuf); }
  1264. Xvoid warnsp(s,t) char *s; char *t;
  1265. X{ if (flagverbose) sprintf(errbuf,"npipekiller: warning: %s%s",s,t); perror(errbuf); }
  1266. X
  1267. Xmain(argc,argv,envp)
  1268. Xint argc;
  1269. Xchar *argv[];
  1270. Xchar *envp[];
  1271. X{
  1272. X int arguid;
  1273. X int uid;
  1274. X int i;
  1275. X int fdserv;
  1276. X int fdlock;
  1277. X char fnlock[200];
  1278. X char fnserv[200];
  1279. X int m;
  1280. X int n;
  1281. X int r;
  1282. X char buf[100];
  1283. X char *uname;
  1284. X int opt;
  1285. X
  1286. X while ((opt = getopt(argc,argv,"qQ")) != EOF)
  1287. X   switch(opt)
  1288. X    {
  1289. X     case 'q':
  1290. X       flagverbose = 0; break;
  1291. X     case 'Q':
  1292. X       flagverbose = 1; break;
  1293. X     case '?':
  1294. X       break; /*XXX*/
  1295. X     default:
  1296. X       break; /*XXX*/
  1297. X    }
  1298. X argc -= optind; argv += optind;
  1299. X
  1300. X if (argc < 2)
  1301. X   die(1,"need at least two arguments");
  1302. X
  1303. X uid = getuid();
  1304. X if (username2uid(argv[0],&arguid) == -1)
  1305. X   dies(2,"cannot figure out username ",argv[0]);
  1306. X
  1307. X if (arguid != uid)
  1308. X   dies(1,"permission denied by ",argv[0]);
  1309. X
  1310. X for (i = 0;argv[0][i];++i)
  1311. X   if ((argv[0][i] == '/') || (argv[0][i] == ':') || (argv[0][i] == '.') || (argv[0][i] == '\n'))
  1312. X     dies(4,"illegal characters in username ",argv[0]);
  1313. X 
  1314. X for (i = 0;argv[1][i];++i)
  1315. X   if ((argv[1][i] == '/') || (argv[1][i] == '.') || (argv[0][i] == '\n'))
  1316. X     dies(5,"illegal characters in service ",argv[1]);
  1317. X
  1318. X signal(SIGPIPE,SIG_IGN);
  1319. X
  1320. X if (uid2username(uid,&uname) == -1) /* will never happen */
  1321. X   die(2,"cannot figure out my own username");
  1322. X
  1323. X if (strlen(NPIPEDIR) + strlen(argv[0]) + strlen(argv[1]) + 1 > 90) /*XXX*/
  1324. X   die(8,"server filenames too long");
  1325. X sprintf(fnserv,"%s/%ds%s",NPIPEDIR,arguid,argv[1]);
  1326. X sprintf(fnlock,"%s/%dl%s",NPIPEDIR,arguid,argv[1]);
  1327. X sprintf(buf,"%d",0);
  1328. X n = strlen(buf);
  1329. X if (n + strlen(uname) + 10 > sizeof(buf))
  1330. X   die(8,"username too long");
  1331. X strcpy(buf + n + 1,uname);
  1332. X n += strlen(uname) + 2;
  1333. X
  1334. X fdlock = open(fnlock,O_RDWR,0);
  1335. X if (fdlock == -1)
  1336. X   diep(1,"cannot open lock file");
  1337. X /* Here's the tricky bit: file locking. :-( */
  1338. X /* XXX: We assume that anyone with named pipes also has lockf(). */
  1339. X if (lockf(fdlock,F_LOCK,1) == -1)
  1340. X   diep(1,"cannot wait for lock on lock file");
  1341. X
  1342. X fdserv = open(fnserv,O_WRONLY,0);
  1343. X if (fdserv == -1)
  1344. X   diep(1,"cannot open server's named pipe");
  1345. X
  1346. X m = 0;
  1347. X r = 0;
  1348. X while ((m < n) && ((r = write(fdserv,buf + m,n - m)) > 0))
  1349. X   m += r;
  1350. X if (r <= 0)
  1351. X   die(1,"cannot tell server to kill itself");
  1352. X
  1353. X exit(0);
  1354. X}
  1355. END_OF_FILE
  1356. if test 3207 -ne `wc -c <'npipekiller.c'`; then
  1357.     echo shar: \"'npipekiller.c'\" unpacked with wrong size!
  1358. fi
  1359. # end of 'npipekiller.c'
  1360. fi
  1361. if test -f 'numeric.c' -a "${1}" != "-c" ; then 
  1362.   echo shar: Will not clobber existing file \"'numeric.c'\"
  1363. else
  1364. echo shar: Extracting \"'numeric.c'\" \(782 characters\)
  1365. sed "s/^X//" >'numeric.c' <<'END_OF_FILE'
  1366. X/* History:
  1367. X6/19/91 DJB added numericdots()
  1368. X5/1/91 DJB baseline public domain
  1369. X*/
  1370. X
  1371. X/*
  1372. X
  1373. Xint numeric(s) char *s; returns 1 if s is entirely composed of the
  1374. Xdigits 0 through 9, 0 otherwise.
  1375. X
  1376. X*/
  1377. X
  1378. X#include "numeric.h"
  1379. X
  1380. Xint numeric(s)
  1381. Xchar *s;
  1382. X{
  1383. X while (*s)
  1384. X  {
  1385. X   if ((*s != '0') && (*s != '1') && (*s != '2') && (*s != '3') && (*s != '4')
  1386. X    && (*s != '5') && (*s != '6') && (*s != '7') && (*s != '8') && (*s != '9'))
  1387. X     return 0;
  1388. X   ++s;
  1389. X  }
  1390. X return 1;
  1391. X}
  1392. X
  1393. Xint numericdots(s)
  1394. Xchar *s;
  1395. X{
  1396. X int dots;
  1397. X
  1398. X dots = 0;
  1399. X while (*s)
  1400. X  {
  1401. X   if ((*s != '0') && (*s != '1') && (*s != '2') && (*s != '3') && (*s != '4')
  1402. X    && (*s != '5') && (*s != '6') && (*s != '7') && (*s != '8') && (*s != '9')
  1403. X    && (*s != '.')
  1404. X    )
  1405. X     return -1;
  1406. X   if (*s == '.')
  1407. X     ++dots;
  1408. X   ++s;
  1409. X  }
  1410. X return dots;
  1411. X}
  1412. END_OF_FILE
  1413. if test 782 -ne `wc -c <'numeric.c'`; then
  1414.     echo shar: \"'numeric.c'\" unpacked with wrong size!
  1415. fi
  1416. # end of 'numeric.c'
  1417. fi
  1418. if test -f 'numeric.h' -a "${1}" != "-c" ; then 
  1419.   echo shar: Will not clobber existing file \"'numeric.h'\"
  1420. else
  1421. echo shar: Extracting \"'numeric.h'\" \(93 characters\)
  1422. sed "s/^X//" >'numeric.h' <<'END_OF_FILE'
  1423. X#ifndef NUMERIC_H
  1424. X#define NUMERIC_H
  1425. X
  1426. Xextern int numeric();
  1427. Xextern int numericdots();
  1428. X
  1429. X#endif
  1430. END_OF_FILE
  1431. if test 93 -ne `wc -c <'numeric.h'`; then
  1432.     echo shar: \"'numeric.h'\" unpacked with wrong size!
  1433. fi
  1434. # end of 'numeric.h'
  1435. fi
  1436. if test -f 'numfiles.h' -a "${1}" != "-c" ; then 
  1437.   echo shar: Will not clobber existing file \"'numfiles.h'\"
  1438. else
  1439. echo shar: Extracting \"'numfiles.h'\" \(82 characters\)
  1440. sed "s/^X//" >'numfiles.h' <<'END_OF_FILE'
  1441. X#ifndef NUMFILES_H
  1442. X#define NUMFILES_H
  1443. X
  1444. X#define NUMFILES (getdtablesize())
  1445. X
  1446. X#endif
  1447. END_OF_FILE
  1448. if test 82 -ne `wc -c <'numfiles.h'`; then
  1449.     echo shar: \"'numfiles.h'\" unpacked with wrong size!
  1450. fi
  1451. # end of 'numfiles.h'
  1452. fi
  1453. if test -f 'portname.c' -a "${1}" != "-c" ; then 
  1454.   echo shar: Will not clobber existing file \"'portname.c'\"
  1455. else
  1456. echo shar: Extracting \"'portname.c'\" \(764 characters\)
  1457. sed "s/^X//" >'portname.c' <<'END_OF_FILE'
  1458. X/* History:
  1459. X6/20/91 DJB added proto arg
  1460. X5/9/91 DJB fixed for backwards architectures, tnx VA
  1461. X5/1/91 DJB baseline public domain
  1462. X*/
  1463. X
  1464. X#include "portname.h"
  1465. X#include "numeric.h"
  1466. X#include <netdb.h>
  1467. X
  1468. X/* XXX: cache */
  1469. X
  1470. Xint port2portname(port,pop,proto)
  1471. Xint port;
  1472. Xchar **pop;
  1473. Xchar *proto;
  1474. X{
  1475. X struct servent *se;
  1476. X static char po[20];
  1477. X
  1478. X if (se = getservbyport(port,proto))
  1479. X  {
  1480. X   *pop = se->s_name;
  1481. X   return 0;
  1482. X  }
  1483. X sprintf(po,"%d",port);
  1484. X *pop = po;
  1485. X return 1;
  1486. X}
  1487. X
  1488. Xint portname2port(po,port,proto)
  1489. Xchar *po;
  1490. Xint *port;
  1491. Xchar *proto;
  1492. X{
  1493. X struct servent *se;
  1494. X
  1495. X if (numeric(po))
  1496. X  {
  1497. X   *port = atoi(po);
  1498. X   return 1;
  1499. X  }
  1500. X se = getservbyname(po,proto);
  1501. X if (!se)
  1502. X   return -1; /*XXX*/
  1503. X *port = ntohs(se->s_port);
  1504. X   /* XXX: stupidity alert: se->s_port is an int! */
  1505. X return 0;
  1506. X}
  1507. END_OF_FILE
  1508. if test 764 -ne `wc -c <'portname.c'`; then
  1509.     echo shar: \"'portname.c'\" unpacked with wrong size!
  1510. fi
  1511. # end of 'portname.c'
  1512. fi
  1513. if test -f 'portname.h' -a "${1}" != "-c" ; then 
  1514.   echo shar: Will not clobber existing file \"'portname.h'\"
  1515. else
  1516. echo shar: Extracting \"'portname.h'\" \(103 characters\)
  1517. sed "s/^X//" >'portname.h' <<'END_OF_FILE'
  1518. X#ifndef PORTNAME_H
  1519. X#define PORTNAME_H
  1520. X
  1521. Xextern int port2portname();
  1522. Xextern int portname2port();
  1523. X
  1524. X#endif
  1525. END_OF_FILE
  1526. if test 103 -ne `wc -c <'portname.h'`; then
  1527.     echo shar: \"'portname.h'\" unpacked with wrong size!
  1528. fi
  1529. # end of 'portname.h'
  1530. fi
  1531. if test -f 'tcpkiller.c' -a "${1}" != "-c" ; then 
  1532.   echo shar: Will not clobber existing file \"'tcpkiller.c'\"
  1533. else
  1534. echo shar: Extracting \"'tcpkiller.c'\" \(2818 characters\)
  1535. sed "s/^X//" >'tcpkiller.c' <<'END_OF_FILE'
  1536. X/* Public domain. */
  1537. X
  1538. X#include <stdio.h>
  1539. X#include <sys/types.h>
  1540. X#include <sys/param.h>
  1541. X#include <sys/file.h>
  1542. X#include <sys/socket.h>
  1543. X#include <signal.h>
  1544. X#include <netinet/in.h>
  1545. X#include "errno.h"
  1546. X#include "username.h"
  1547. X#include "hostname.h"
  1548. X#include "portname.h"
  1549. X#include "getopt.h"
  1550. X#include "malloc.h"
  1551. X#include "env.h"
  1552. X
  1553. X#ifndef MAXHOSTNAMELEN
  1554. X#define MAXHOSTNAMELEN 64
  1555. X#endif
  1556. X
  1557. Xstatic int flagverbose = 1;
  1558. X
  1559. Xstatic char errbuf[500];
  1560. Xvoid die(n,s) int n; char *s;
  1561. X{ if (flagverbose) fprintf(stderr,"tcpkiller: fatal: %s\n",s); exit(n); }
  1562. Xvoid dies(n,s,t) int n; char *s; char *t;
  1563. X{ if (flagverbose) fprintf(stderr,"tcpkiller: fatal: %s%s\n",s,t); exit(n); }
  1564. Xvoid diep(n,s) int n; char *s;
  1565. X{ if (flagverbose) sprintf(errbuf,"tcpkiller: fatal: %s",s); perror(errbuf); exit(n); }
  1566. Xvoid warnp(s) char *s;
  1567. X{ if (flagverbose) sprintf(errbuf,"tcpkiller: warning: %s",s); perror(errbuf); }
  1568. Xvoid warnsp(s,t) char *s; char *t;
  1569. X{ if (flagverbose) sprintf(errbuf,"tcpkiller: warning: %s%s",s,t); perror(errbuf); }
  1570. X
  1571. Xmain(argc,argv,envp)
  1572. Xint argc;
  1573. Xchar *argv[];
  1574. Xchar *envp[];
  1575. X{
  1576. X int uid;
  1577. X int opt;
  1578. X char lochost[MAXHOSTNAMELEN];
  1579. X int locport;
  1580. X char *home;
  1581. X char *fnrecord;
  1582. X char pidstr[50];
  1583. X int pid;
  1584. X int fd;
  1585. X
  1586. X while ((opt = getopt(argc,argv,"qQ")) != EOF)
  1587. X   switch(opt)
  1588. X    {
  1589. X     case 'q':
  1590. X       flagverbose = 0; break;
  1591. X     case 'Q':
  1592. X       flagverbose = 1; break;
  1593. X     case '?':
  1594. X       break; /*XXX*/
  1595. X     default:
  1596. X       break; /*XXX*/
  1597. X    }
  1598. X argc -= optind; argv += optind;
  1599. X
  1600. X if (argc < 2)
  1601. X   die(1,"need at least two arguments");
  1602. X
  1603. X uid = getuid();
  1604. X
  1605. X gethostname(lochost,sizeof(lochost));
  1606. X
  1607. X if ((argv[0][0] == '0') && (argv[0][1] == 0))
  1608. X   ; /* local host, fine */
  1609. X else
  1610. X  {
  1611. X   struct in_addr inaddr1;
  1612. X   struct in_addr inaddr2;
  1613. X   if (hostname2inaddr(argv[0],&inaddr1) == -1)
  1614. X     dies(2,"cannot figure out hostname ",argv[0]);
  1615. X   if (hostname2inaddr(lochost,&inaddr2) == -1)
  1616. X     die(2,"cannot figure out my own hostname");
  1617. X   /* XXX: this doesn't allow 127.1 */
  1618. X   if (inaddr1.s_addr != inaddr2.s_addr)
  1619. X     dies(2,"host does not match local host ",argv[0]);
  1620. X  }
  1621. X
  1622. X if (portname2port(argv[1],&locport,"tcp") == -1)
  1623. X   dies(2,"cannot figure out portname ",argv[1]);
  1624. X locport = locport & 65535;
  1625. X
  1626. X home = env_get("TCPHOME");
  1627. X if (!home)
  1628. X  {
  1629. X   home = env_get("HOME");
  1630. X   if (!home)
  1631. X     die(1,"cannot find TCPHOME or HOME in environment");
  1632. X  }
  1633. X fnrecord = malloc(strlen(home) + strlen(lochost) + 100);
  1634. X if (!fnrecord)
  1635. X   die(1,"out of memory");
  1636. X sprintf(fnrecord,"%s/.tcpserver.%s.%d.%d",home,lochost,uid,locport);
  1637. X
  1638. X fd = open(fnrecord,O_RDONLY,0400);
  1639. X if (fd == -1)
  1640. X   dies(1,"cannot open ",fnrecord);
  1641. X
  1642. X read(fd,pidstr,sizeof(pidstr)); /* XXX: check for partial reads */
  1643. X if (sscanf(pidstr,"%d",&pid) != 1)
  1644. X   die(1,"cannot figure out pid of tcpserver");
  1645. X
  1646. X close(fd);
  1647. X
  1648. X kill(pid,SIGTERM); /*XXX: report errors? */
  1649. X
  1650. X exit(0);
  1651. X}
  1652. END_OF_FILE
  1653. if test 2818 -ne `wc -c <'tcpkiller.c'`; then
  1654.     echo shar: \"'tcpkiller.c'\" unpacked with wrong size!
  1655. fi
  1656. # end of 'tcpkiller.c'
  1657. fi
  1658. if test -f 'testmain' -a "${1}" != "-c" ; then 
  1659.   echo shar: Will not clobber existing file \"'testmain'\"
  1660. else
  1661. echo shar: Extracting \"'testmain'\" \(269 characters\)
  1662. sed "s/^X//" >'testmain' <<'END_OF_FILE'
  1663. X#!/bin/sh
  1664. X# testmain args
  1665. X./testucspi ${1+"$@"} | sed 's/=.*//' > .ucspi.$$
  1666. X./testresult ${1+"$@"} | sed 's/=.*//' > .result.$$
  1667. Xif cmp .ucspi.$$ .result.$$ >/dev/null 2>&1
  1668. Xthen echo 'Everything compares okay.'
  1669. Xelse echo 'Aaack! Test failed.'
  1670. Xfi
  1671. Xrm .ucspi.$$ .result.$$
  1672. END_OF_FILE
  1673. if test 269 -ne `wc -c <'testmain'`; then
  1674.     echo shar: \"'testmain'\" unpacked with wrong size!
  1675. fi
  1676. chmod +x 'testmain'
  1677. # end of 'testmain'
  1678. fi
  1679. if test -f 'testresult' -a "${1}" != "-c" ; then 
  1680.   echo shar: Will not clobber existing file \"'testresult'\"
  1681. else
  1682. echo shar: Extracting \"'testresult'\" \(915 characters\)
  1683. sed "s/^X//" >'testresult' <<'END_OF_FILE'
  1684. X#!/bin/sh
  1685. X# testresult proto prog address
  1686. X# XXX: test args
  1687. Xproto="$1"; shift; export proto
  1688. Xprog="$1"; shift
  1689. Xclient=./"$prog"client; export client
  1690. Xserver=./"$prog"server; export server
  1691. Xkiller=./"$prog"killer; export killer
  1692. Xecho "$server started, ${proto}LOCAL=(depends on the protocol)"
  1693. Xecho "$client started"
  1694. Xecho "$client connected to ${proto}REMOTE=(depends on the protocol)"
  1695. Xecho "$client reading line from server..."
  1696. Xecho "$server accepted connection from ${proto}REMOTE=(depends on the protocol)"
  1697. Xecho "$server writing line to client..."
  1698. Xecho "$client received from server: is anybody out there..."
  1699. Xecho "$client writing line to server..."
  1700. Xecho "$server reading line from client..."
  1701. Xecho "$server received from client: is anybody in there..."
  1702. Xecho "$server done with connection"
  1703. Xecho "$client done with connection"
  1704. Xecho "$client finished"
  1705. Xecho "$killer started"
  1706. Xecho "$server finished"
  1707. Xecho "$killer finished"
  1708. END_OF_FILE
  1709. if test 915 -ne `wc -c <'testresult'`; then
  1710.     echo shar: \"'testresult'\" unpacked with wrong size!
  1711. fi
  1712. chmod +x 'testresult'
  1713. # end of 'testresult'
  1714. fi
  1715. if test -f 'testucspi' -a "${1}" != "-c" ; then 
  1716.   echo shar: Will not clobber existing file \"'testucspi'\"
  1717. else
  1718. echo shar: Extracting \"'testucspi'\" \(1220 characters\)
  1719. sed "s/^X//" >'testucspi' <<'END_OF_FILE'
  1720. X#!/bin/sh
  1721. X# testucspi proto prog address
  1722. X# XXX: test args
  1723. Xproto="$1"; shift; export proto
  1724. Xprog="$1"; shift
  1725. Xclient=./"$prog"client; export client
  1726. Xserver=./"$prog"server; export server
  1727. Xkiller=./"$prog"killer; export killer
  1728. X
  1729. X( 
  1730. Xecho "$server started, ${proto}LOCAL=" | tr -d '\012'
  1731. X# blessed be the shells that allow "$server" here
  1732. X$server -4 "$@" sh -c '
  1733. X  exec <&6
  1734. X  sleep 5
  1735. X  echo "$server accepted connection from ${proto}REMOTE=" | tr -d "\012"
  1736. X  printenv ${proto}REMOTE
  1737. X  echo "$server writing line to client..."
  1738. X  echo "is anybody out there..." >&7
  1739. X  sleep 5
  1740. X  echo "$server reading line from client..."
  1741. X  read i
  1742. X  echo "$server received from client: $i"
  1743. X  echo "$server done with connection"
  1744. X' 4>&1 
  1745. Xecho "$server finished"
  1746. X) &
  1747. X
  1748. Xsleep 5
  1749. X
  1750. Xecho "$client started"
  1751. X$client "$@" sh -c '
  1752. X  exec <&6
  1753. X  sleep 1
  1754. X  echo "$client connected to ${proto}REMOTE=" | tr -d "\012"
  1755. X  printenv ${proto}REMOTE
  1756. X  echo "$client reading line from server..."
  1757. X  read i
  1758. X  echo "$client received from server: $i"
  1759. X  echo "$client writing line to server..."
  1760. X  echo "is anybody in there..." >&7
  1761. X  sleep 5
  1762. X  echo "$client done with connection"
  1763. X'
  1764. Xecho "$client finished"
  1765. X
  1766. Xecho "$killer started"
  1767. Xeval "$killer" "$@"
  1768. Xsleep 2
  1769. Xecho "$killer finished"
  1770. END_OF_FILE
  1771. if test 1220 -ne `wc -c <'testucspi'`; then
  1772.     echo shar: \"'testucspi'\" unpacked with wrong size!
  1773. fi
  1774. chmod +x 'testucspi'
  1775. # end of 'testucspi'
  1776. fi
  1777. if test -f 'undomclient.c' -a "${1}" != "-c" ; then 
  1778.   echo shar: Will not clobber existing file \"'undomclient.c'\"
  1779. else
  1780. echo shar: Extracting \"'undomclient.c'\" \(3980 characters\)
  1781. sed "s/^X//" >'undomclient.c' <<'END_OF_FILE'
  1782. X/* Public domain. */
  1783. X
  1784. X#include <stdio.h>
  1785. X#include <sys/types.h>
  1786. X#include <sys/socket.h>
  1787. X#include <sys/un.h>
  1788. X#include <signal.h>
  1789. X#include "dupdup.h"
  1790. X#include "malloc.h"
  1791. X#include "errno.h"
  1792. X#include "username.h"
  1793. X#include "env.h"
  1794. X#include "getopt.h"
  1795. X#include "numfiles.h"
  1796. X
  1797. Xstatic int flagverbose = 1;
  1798. Xstatic struct sockaddr_un sa;
  1799. X
  1800. Xstatic char errbuf[500];
  1801. Xvoid die(n,s) int n; char *s;
  1802. X{ if (flagverbose) fprintf(stderr,"undomclient: fatal: %s\n",s); exit(n); }
  1803. Xvoid dies(n,s,t) int n; char *s; char *t;
  1804. X{ if (flagverbose) fprintf(stderr,"undomclient: fatal: %s%s\n",s,t); exit(n); }
  1805. Xvoid diep(n,s) int n; char *s;
  1806. X{ if (flagverbose) sprintf(errbuf,"undomclient: fatal: %s",s); perror(errbuf); exit(n); }
  1807. Xvoid warnp(s) char *s;
  1808. X{ if (flagverbose) sprintf(errbuf,"undomclient: warning: %s",s); perror(errbuf); }
  1809. Xvoid warnsp(s,t) char *s; char *t;
  1810. X{ if (flagverbose) sprintf(errbuf,"undomclient: warning: %s%s",s,t); perror(errbuf); }
  1811. X
  1812. Xmain(argc,argv,envp)
  1813. Xint argc;
  1814. Xchar *argv[];
  1815. Xchar *envp[];
  1816. X{
  1817. X int t;
  1818. X int *d;
  1819. X int tdup;
  1820. X int numfiles;
  1821. X int arguid;
  1822. X int uid;
  1823. X int i;
  1824. X static char undomlocal[200];
  1825. X static char undomremote[300];
  1826. X unsigned char urlen;
  1827. X char *uname;
  1828. X int opt;
  1829. X
  1830. X while ((opt = getopt(argc,argv,"qQ")) != EOF)
  1831. X   switch(opt)
  1832. X    {
  1833. X     case 'q':
  1834. X       flagverbose = 0; break;
  1835. X     case 'Q':
  1836. X       flagverbose = 1; break;
  1837. X     case '?':
  1838. X       break; /*XXX*/
  1839. X     default:
  1840. X       break; /*XXX*/
  1841. X    }
  1842. X argc -= optind; argv += optind;
  1843. X
  1844. X if (argc < 3)
  1845. X   die(1,"need at least three arguments");
  1846. X
  1847. X uid = getuid();
  1848. X if (username2uid(argv[0],&arguid) == -1)
  1849. X   dies(2,"cannot figure out username ",argv[0]);
  1850. X /* XXX: any permission checks? */
  1851. X
  1852. X for (i = 0;argv[0][i];++i)
  1853. X   if ((argv[0][i] == '/') || (argv[0][i] == ':') || (argv[0][i] == '.') || (argv[0][i] == '\n'))
  1854. X     dies(4,"illegal characters in username ",argv[0]);
  1855. X 
  1856. X for (i = 0;argv[1][i];++i)
  1857. X   if ((argv[1][i] == '/') || (argv[1][i] == '.') || (argv[0][i] == '\n'))
  1858. X     dies(5,"illegal characters in service ",argv[1]);
  1859. X
  1860. X close(6);
  1861. X close(7); /* XXX: these have implications that should be documented */
  1862. X
  1863. X signal(SIGPIPE,SIG_IGN);
  1864. X
  1865. X if (uid2username(uid,&uname) == -1) /* will never happen */
  1866. X   die(2,"cannot figure out my own username");
  1867. X urlen = strlen(uname) + 1;
  1868. X
  1869. X numfiles = NUMFILES;
  1870. X d = (int *) malloc(numfiles * sizeof(int));
  1871. X if (!d)
  1872. X   die(6,"cannot malloc");
  1873. X for (i = 0;i < numfiles;++i)
  1874. X   d[i] = -1;
  1875. X
  1876. X if (strlen(UNDOMDIR) + strlen(argv[0]) + strlen(argv[1]) + 1 > 100) /*XXX*/
  1877. X   die(8,"server socket name too long");
  1878. X sprintf(sa.sun_path,"%s/%s:%s",UNDOMDIR,argv[0],argv[1]);
  1879. X
  1880. X if (env_init() == -1)
  1881. X   die(11,"cannot init environment");
  1882. X if (env_put("PROTO=UNDOM") == -1)
  1883. X   die(11,"out of memory putting PROTO into environment");
  1884. X sprintf(undomlocal,"UNDOMLOCAL=%s",uname);
  1885. X if (env_put(undomlocal) == -1)
  1886. X   die(11,"out of memory putting UNDOMLOCAL into environment");
  1887. X sprintf(undomremote,"UNDOMREMOTE=%s:%s",argv[0],argv[1]);
  1888. X if (env_put(undomremote) == -1)
  1889. X   die(11,"out of memory putting UNDOMREMOTE into environment");
  1890. X
  1891. X t = socket(AF_UNIX,SOCK_STREAM,0);
  1892. X if (t == -1)
  1893. X   diep(7,"cannot create client socket");
  1894. X sa.sun_family = AF_UNIX;
  1895. X if (connect(t,&sa,sizeof(sa)) == -1)
  1896. X   diep(9,"cannot connect to server");
  1897. X
  1898. X /* XXX: fork? not necessary here */
  1899. X
  1900. X if ((i = write(t,&urlen,1)) == -1)
  1901. X   diep(1,"cannot write length of local username");
  1902. X if (!i) /* ever? */
  1903. X   die(1,"cannot write length of local username");
  1904. X if (write(t,uname,urlen) < urlen)
  1905. X   die(1,"cannot write local username");
  1906. X
  1907. X tdup = dup(t);
  1908. X if (tdup == -1)
  1909. X   diep(10,"cannot dup connection to server");
  1910. X
  1911. X /* Now put t into descriptor 6 and tdup into descriptor 7. */
  1912. X /* XXX: should check that t and tdup are small enough */
  1913. X d[t] = 6;
  1914. X d[tdup] = 7;
  1915. X if (dupdup(d,numfiles) == -1)
  1916. X   diep(10,"cannot dup connection to server");
  1917. X
  1918. X if (setreuid(uid,uid) == -1)
  1919. X   diep(1,"cannot setreuid"); /* will never happen */
  1920. X signal(SIGPIPE,SIG_DFL);
  1921. X execvp(argv[2],argv + 2);
  1922. X warnsp("cannot exec ",argv[2]);
  1923. X exit(1);
  1924. X}
  1925. END_OF_FILE
  1926. if test 3980 -ne `wc -c <'undomclient.c'`; then
  1927.     echo shar: \"'undomclient.c'\" unpacked with wrong size!
  1928. fi
  1929. # end of 'undomclient.c'
  1930. fi
  1931. if test -f 'undomkiller.c' -a "${1}" != "-c" ; then 
  1932.   echo shar: Will not clobber existing file \"'undomkiller.c'\"
  1933. else
  1934. echo shar: Extracting \"'undomkiller.c'\" \(2703 characters\)
  1935. sed "s/^X//" >'undomkiller.c' <<'END_OF_FILE'
  1936. X/* Public domain. */
  1937. X
  1938. X#include <stdio.h>
  1939. X#include <sys/types.h>
  1940. X#include <sys/socket.h>
  1941. X#include <sys/un.h>
  1942. X#include <signal.h>
  1943. X#include "errno.h"
  1944. X#include "username.h"
  1945. X#include "getopt.h"
  1946. X
  1947. Xstatic int flagverbose = 1;
  1948. Xstatic struct sockaddr_un sa;
  1949. X
  1950. Xstatic char errbuf[500];
  1951. Xvoid die(n,s) int n; char *s;
  1952. X{ if (flagverbose) fprintf(stderr,"undomkiller: fatal: %s\n",s); exit(n); }
  1953. Xvoid dies(n,s,t) int n; char *s; char *t;
  1954. X{ if (flagverbose) fprintf(stderr,"undomkiller: fatal: %s%s\n",s,t); exit(n); }
  1955. Xvoid diep(n,s) int n; char *s;
  1956. X{ if (flagverbose) sprintf(errbuf,"undomkiller: fatal: %s",s); perror(errbuf); exit(n); }
  1957. Xvoid warnp(s) char *s;
  1958. X{ if (flagverbose) sprintf(errbuf,"undomkiller: warning: %s",s); perror(errbuf); }
  1959. Xvoid warnsp(s,t) char *s; char *t;
  1960. X{ if (flagverbose) sprintf(errbuf,"undomkiller: warning: %s%s",s,t); perror(errbuf); }
  1961. X
  1962. Xmain(argc,argv,envp)
  1963. Xint argc;
  1964. Xchar *argv[];
  1965. Xchar *envp[];
  1966. X{
  1967. X int t;
  1968. X int arguid;
  1969. X int uid;
  1970. X int i;
  1971. X unsigned char urlen;
  1972. X char *uname;
  1973. X int opt;
  1974. X
  1975. X while ((opt = getopt(argc,argv,"qQ")) != EOF)
  1976. X   switch(opt)
  1977. X    {
  1978. X     case 'q':
  1979. X       flagverbose = 0; break;
  1980. X     case 'Q':
  1981. X       flagverbose = 1; break;
  1982. X     case '?':
  1983. X       break; /*XXX*/
  1984. X     default:
  1985. X       break; /*XXX*/
  1986. X    }
  1987. X argc -= optind; argv += optind;
  1988. X
  1989. X if (argc < 2)
  1990. X   die(1,"need at least two arguments");
  1991. X
  1992. X uid = getuid();
  1993. X if (username2uid(argv[0],&arguid) == -1)
  1994. X   dies(2,"cannot figure out username ",argv[0]);
  1995. X
  1996. X if (arguid != uid)
  1997. X   dies(15,"permission denied by ",argv[0]);
  1998. X /* XXX: special-case root? more checks? */
  1999. X /* This is enough to prevent one user from wasting another's CPU time. */
  2000. X
  2001. X for (i = 0;argv[0][i];++i)
  2002. X   if ((argv[0][i] == '/') || (argv[0][i] == ':') || (argv[0][i] == '.') || (argv[0][i] == '\n'))
  2003. X     dies(4,"illegal characters in username ",argv[0]);
  2004. X 
  2005. X for (i = 0;argv[1][i];++i)
  2006. X   if ((argv[1][i] == '/') || (argv[1][i] == '.') || (argv[0][i] == '\n'))
  2007. X     dies(5,"illegal characters in service ",argv[1]);
  2008. X
  2009. X if (uid2username(uid,&uname) == -1) /* will never happen */
  2010. X   die(2,"cannot figure out my own username");
  2011. X urlen = strlen(uname) + 1;
  2012. X
  2013. X if (strlen(UNDOMDIR) + strlen(argv[0]) + strlen(argv[1]) + 1 > 100) /*XXX*/
  2014. X   die(8,"server socket name too long");
  2015. X sprintf(sa.sun_path,"%s/%s:%s",UNDOMDIR,argv[0],argv[1]);
  2016. X
  2017. X t = socket(AF_UNIX,SOCK_STREAM,0);
  2018. X if (t == -1)
  2019. X   diep(7,"cannot create killer socket");
  2020. X sa.sun_family = AF_UNIX;
  2021. X if (connect(t,&sa,sizeof(sa)) == -1)
  2022. X   diep(9,"cannot connect to server");
  2023. X
  2024. X signal(SIGPIPE,SIG_IGN);
  2025. X
  2026. X urlen = 0; /* XXX: this signals server to clean up and die */
  2027. X if ((i = write(t,&urlen,1)) == -1)
  2028. X   diep(1,"cannot kill server");
  2029. X if (!i) /* ever? */
  2030. X   die(1,"cannot kill server");
  2031. X
  2032. X exit(0);
  2033. X}
  2034. END_OF_FILE
  2035. if test 2703 -ne `wc -c <'undomkiller.c'`; then
  2036.     echo shar: \"'undomkiller.c'\" unpacked with wrong size!
  2037. fi
  2038. # end of 'undomkiller.c'
  2039. fi
  2040. if test -f 'username.c' -a "${1}" != "-c" ; then 
  2041.   echo shar: Will not clobber existing file \"'username.c'\"
  2042. else
  2043. echo shar: Extracting \"'username.c'\" \(549 characters\)
  2044. sed "s/^X//" >'username.c' <<'END_OF_FILE'
  2045. X/* History:
  2046. X5/1/91 DJB baseline public domain
  2047. X*/
  2048. X
  2049. X#include <pwd.h>
  2050. X#include "username.h"
  2051. X#include "numeric.h"
  2052. X
  2053. X/*XXX: cache */
  2054. X
  2055. Xint uid2username(uid,unp)
  2056. Xint uid;
  2057. Xchar **unp;
  2058. X{
  2059. X struct passwd *pw;
  2060. X static char un[20];
  2061. X
  2062. X if (pw = getpwuid(uid))
  2063. X  {
  2064. X   *unp = pw->pw_name;
  2065. X   return 0;
  2066. X  }
  2067. X sprintf(un,"%d",uid);
  2068. X *unp = un;
  2069. X return 1;
  2070. X}
  2071. X
  2072. Xint username2uid(un,uid)
  2073. Xchar *un;
  2074. Xint *uid;
  2075. X{
  2076. X struct passwd *pw;
  2077. X
  2078. X if (numeric(un))
  2079. X  {
  2080. X   *uid = atoi(un);
  2081. X   return 1;
  2082. X  }
  2083. X pw = getpwnam(un);
  2084. X if (!pw)
  2085. X   return -1; /*XXX*/
  2086. X *uid = pw->pw_uid;
  2087. X return 0;
  2088. X}
  2089. END_OF_FILE
  2090. if test 549 -ne `wc -c <'username.c'`; then
  2091.     echo shar: \"'username.c'\" unpacked with wrong size!
  2092. fi
  2093. # end of 'username.c'
  2094. fi
  2095. if test -f 'username.h' -a "${1}" != "-c" ; then 
  2096.   echo shar: Will not clobber existing file \"'username.h'\"
  2097. else
  2098. echo shar: Extracting \"'username.h'\" \(101 characters\)
  2099. sed "s/^X//" >'username.h' <<'END_OF_FILE'
  2100. X#ifndef USERNAME_H
  2101. X#define USERNAME_H
  2102. X
  2103. Xextern int uid2username();
  2104. Xextern int username2uid();
  2105. X
  2106. X#endif
  2107. END_OF_FILE
  2108. if test 101 -ne `wc -c <'username.h'`; then
  2109.     echo shar: \"'username.h'\" unpacked with wrong size!
  2110. fi
  2111. # end of 'username.h'
  2112. fi
  2113. echo shar: End of archive 1 \(of 2\).
  2114. cp /dev/null ark1isdone
  2115. MISSING=""
  2116. for I in 1 2 ; do
  2117.     if test ! -f ark${I}isdone ; then
  2118.     MISSING="${MISSING} ${I}"
  2119.     fi
  2120. done
  2121. if test "${MISSING}" = "" ; then
  2122.     echo You have unpacked both archives.
  2123.     rm -f ark[1-9]isdone
  2124. else
  2125.     echo You still need to unpack the following archives:
  2126.     echo "        " ${MISSING}
  2127. fi
  2128. ##  End of shell archive.
  2129. exit 0
  2130.