开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
dirsend.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：26k
源码类别：

代理服务器

开发平台：

Unix_Linux

dirsend.c：源码内容
  1. /*  Copyright (c) 1989, 1990, 1991 by the University of Washington           */
  2. /*                                                                           */
  3. /*   For copying and distribution information, please see the file           */
  4. /*   <copyright.h>.                                                          */
  6. /* If you're going to hack on this, I'd suggest using unifdef with -UCUTCP   */
  7. /* for your working copy.  When you've got your changes done, come back and  */
  8. /* add them into this main file.  It's getting pretty nasty down there.      */
  9. #include "pmachine.h"
  11. /* THIS does FD_SET etc on AT&T 3b2s.                                        */
  12. #ifdef u3b2
  13. # include <sys/inet.h> 
  14. #endif 
  16. /* Interactive UNIX keeps some of the socket definitions in funny places.    */
  17. #ifdef ISC
  18. # include <net/errno.h>
  19. #endif /* ISC */
  21. #include "pfs.h"
  22. #include "pprot.h"
  23. #include "pcompat.h"
  24. #include "perrno.h"
  26. static int notprived = 0;
  27. extern int errno;
  28. extern int perrno;
  29. extern int rdgram_priority;
  30. #ifdef DEBUG
  31. extern int pfs_debug;
  32. #endif
  33. extern int pfs_disable_flag;
  35. extern int verbose;
  37. char *nlsindex();
  39. #define max(X, Y)  ((X) > (Y) ? (X) : (Y))
  41. static int dir_udp_port = 0; /* Remote UDP port number */
  43. static unsigned short next_conn_id = 0;
  45. static int client_dirsrv_timeout = CLIENT_DIRSRV_TIMEOUT;
  46. static int client_dirsrv_retry = CLIENT_DIRSRV_RETRY; 
  48. /* These were parameters to dirsend() */
  49. static PTEXT pkt;
  50. static char *hostname;
  51. static struct sockaddr_in *hostaddr;
  53. /* These were locals in dirsend(). Note that the initializations here
  54.  * are really meaningless since we have to redo them for each call to
  55.  * dirsend() since they were formerly automatically initialized.
  56.  */
  57. static PTEXT first = NULL; /* First returned packet  */
  58. static PTEXT next; /* The one we are waiting for   */
  59. static PTEXT vtmp;           /* For reorganizing linked list  */
  60. static PTEXT comp_thru; /* We have all packets though    */
  61. static int lp = -1; /* Opened UDP port          */
  62. static int hdr_len; /* Header Length                 */
  63. static int nd_pkts; /* Number of packets we want     */
  64. static int no_pkts; /* Number of packets we have     */
  65. static int pkt_cid;        /* Packet connection identifier  */
  66. static unsigned short this_conn_id; /* Connection ID we are using    */
  67. static unsigned short recvd_thru; /* Received through              */
  68. static short priority; /* Priority for request          */
  69. static short one = 0; /* Pointer to value 1            */
  70. static short zero = 0; /* Pointer to value 0  */
  71. static char *seqtxt; /* Pointer to text w/ sequence # */
  72. static struct sockaddr_in  us; /* Our address                   */
  73. static struct sockaddr_in  to; /* Address to send query  */
  74. static struct sockaddr_in  from; /* Reply received from  */
  75. static int from_sz; /* Size of from structure  */
  76. static struct hostent *host; /* Host info from gethostbyname  */
  77. static long newhostaddr;    /* New host address from *host   */
  78. static int req_udp_port=0; /* Requested port (optional)     */
  79. static char *openparen; /* Delimits port in name         */
  80. static char hostnoport[500];/* Host name without port        */
  81. static int ns; /* Number of bytes actually sent */
  82. static int nr; /* Number of bytes received      */
  83. static SELECTARG readfds; /* Used for select  */
  84. static int tmp;
  85. static char *ctlptr; /* Pointer to control field      */
  86. static short stmp; /* Temp short for conversions    */
  87. static int backoff; /* Server requested backoff      */
  88. static unsigned char rdflag11; /* First byte of flags (bit vect)*/
  89. static unsigned char rdflag12; /* Second byte of flags (int)    */
  90. static int scpflag = 0; /* Set if any sequencd cont pkts */
  91. static int ackpend = 0;    /* Acknowledgement pending      */
  92. static int gaps = 0; /* Gaps present in recvd pkts   */
  93. static struct timeval timeout; /* Time to wait for response    */
  94. static struct timeval ackwait; /* Time to wait before acking   */
  95. static struct timeval gapwait; /* Time to wait b4 filling gaps */
  96. static struct timeval *selwait; /* Time to wait for select      */
  97. static int retries; /* was = client_dirsrv_retry    */
  98. char   to_hostname[512]; /* lmjm: saves inet_ntoa() str  */
  100. /* These are added so dirsend() "blocks" properly */
  101. static PTEXT dirsendReturn;
  102. static int dirsendDone;
  104. /* And here are the values for dirsendDone */
  105. #define DSRET_DONE 1
  106. #define DSRET_SEND_ERROR -1
  107. #define DSRET_RECV_ERROR -2
  108. #define DSRET_SELECT_ERROR -3
  109. #define DSRET_TIMEOUT -4
  110. #define DSRET_ABORTED -5
  112. /* New procedures to break up dirsend() */
  113. static int initDirsend();
  114. static void retryDirsend(), keepWaitingDirsend();
  115. static void timeoutProc();
  116. static void readProc();
  118. /* Wrappers around X calls to allow non-X usage */
  119. static void processEvent();
  121. /* Extra stuff for the asynchronous X version of dirsend() */
  122. typedef char *XtPointer;
  123. typedef char *XtInputId;
  124. typedef char *XtIntervalId;
  126. static XtInputId inputId;
  127. static XtIntervalId timerId = (XtIntervalId)0;
  129. /*
  130.  * dirsend - send packet and receive response
  131.  *
  132.  *   DIRSEND takes a pointer to a structure of type PTEXT, a hostname,
  133.  *   and a pointer to a host address.  It then sends the supplied
  134.  *   packet off to the directory server on the specified host.  If
  135.  *   hostaddr points to a valid address, that address is used.  Otherwise,
  136.  *   the hostname is looked up to obtain the address.  If hostaddr is a
  137.  *   non-null pointer to a 0 address, then the address will be replaced
  138.  *   with that found in the hostname lookup.
  139.  *
  140.  *   DIRSEND will wait for a response and retry an appropriate
  141.  *   number of times as defined by timeout and retries (both static
  142.  *   variables).  It will collect however many packets form the reply, and
  143.  *   return them in a structure (or structures) of type PTEXT.
  144.  *
  145.  *   DIRSEND will free the packet that it is presented as an argument.
  146.  *   The packet is freed even if dirsend fails.
  147.  */
  148. PTEXT
  149. dirsend(pkt_p,hostname_p,hostaddr_p)
  150.     PTEXT pkt_p;
  151.     char *hostname_p;
  152.     struct sockaddr_in *hostaddr_p;
  153. {
  154.     /* copy parameters to globals since other routines use them */
  155.     pkt = pkt_p;
  156.     hostname = hostname_p;
  157.     hostaddr = hostaddr_p;
  158.     /* Do the initializations of formerly auto variables */
  159.     first = NULL;
  160.     lp = -1;
  161.     one = 0;
  162.     zero = 0;
  163.     req_udp_port=0;
  164.     scpflag = 0;
  165.     ackpend = 0;
  166.     gaps = 0;
  167.     retries = client_dirsrv_retry;
  169.     if (initDirsend() < 0)
  170. return(NULL);
  172.     /* set the first timeout */
  173.     retryDirsend();
  175.     dirsendReturn = NULL;
  176.     dirsendDone = 0;
  177.     /* Until one of the callbacks says to return, keep processing events */
  178.     while (!dirsendDone)
  179. processEvent();
  181.     /* Return whatever we're supposed to */
  182.     return(dirsendReturn);
  183. }
  186. /* - - - - - - - - */
  187. /* This function does all the initialization that used to be done at the
  188.  * start of dirsend(), including opening the socket descriptor "lp". It
  189.  * returns the descriptor if successful, otherwise -1 to indicate that
  190.  * dirsend() should return NULL immediately.
  191.  */
  192. static int
  193. initDirsend()
  194. {
  195.     if(one == 0) one = htons((short) 1);
  197.     priority = htons(rdgram_priority);
  199.     timeout.tv_sec = client_dirsrv_timeout;
  200.     timeout.tv_usec = 0;
  202.     ackwait.tv_sec = 0;
  203.     ackwait.tv_usec = 500000;
  205.     gapwait.tv_sec = (client_dirsrv_timeout < 5 ? client_dirsrv_timeout : 5);
  206.     gapwait.tv_usec = 0;
  208.     comp_thru = NULL;
  209.     perrno = 0;
  210.     nd_pkts = 0;
  211.     no_pkts = 0;
  212.     pkt_cid = 0;
  214.     /* Find first connection ID */
  215.     if(next_conn_id == 0) {
  216. srand(getpid()+time(0)); /* XXX: arg ok, but not right type. */
  217. next_conn_id = rand();
  218.     }
  221.     /* If necessary, find out what udp port to send to */
  222.     if (dir_udp_port == 0) {
  223.         register struct servent *sp;
  224. tmp = pfs_enable; pfs_enable = PMAP_DISABLE;
  225. #ifdef USE_ASSIGNED_PORT
  226. /* UCX needs 0 & -1 */
  227.         sp = getservbyname("prospero","udp");
  228. if (sp == (struct servent *)0 || sp == (struct servent *)-1) {
  229. #ifdef DEBUG
  230.     if (pfs_debug)
  231. fprintf(stderr, "dirsrv: udp/prospero unknown service - using %dn", 
  232. PROSPERO_PORT);
  233. #endif
  234.     dir_udp_port = htons((u_short) PROSPERO_PORT);
  235.         }
  236. #else
  237. /* UCX needs 0 & -1 */
  238.         sp = getservbyname("dirsrv","udp");
  239. if (sp == (struct servent *)0 || sp == (struct servent *)-1) {
  240. #ifdef DEBUG
  241.     if (pfs_debug)
  242. fprintf(stderr, "dirsrv: udp/dirsrv unknown service - using %dn", 
  243. DIRSRV_PORT);
  244. #endif
  245.     dir_udp_port = htons((u_short) DIRSRV_PORT);
  246.         }
  247. #endif
  248. else dir_udp_port = sp->s_port;
  249. pfs_enable = tmp;
  250. #ifdef DEBUG
  251.         if (pfs_debug > 3)
  252.             fprintf(stderr,"dir_udp_port is %dn", ntohs(dir_udp_port));
  253. #endif
  254.     }
  256.     /* If we were given the host address, then use it.  Otherwise  */
  257.     /* lookup the hostname.  If we were passed a host address of   */
  258.     /* 0, we must lookup the host name, then replace the old value */
  259.     if(!hostaddr || (hostaddr->sin_addr.s_addr == 0)) {
  260. /* I we have a null host name, return an error */
  261. if((hostname == NULL) || (*hostname == '')) {
  262. #ifdef DEBUG
  263.             if (pfs_debug)
  264.                 fprintf(stderr, "dirsrv: Null hostname specifiedn");
  265. #endif
  266.     perrno = DIRSEND_BAD_HOSTNAME;
  267.     ptlfree(pkt);
  268.             /* return(NULL); */
  269.     return(-1);
  270. }
  271. /* If a port is included, save it away */
  272. if((openparen = index(hostname,'('))) {
  273.     sscanf(openparen+1,"%d",&req_udp_port);
  274.     strncpy(hostnoport,hostname,400);
  275.     if((openparen - hostname) < 400) {
  276. *(hostnoport + (openparen - hostname)) = '';
  277. hostname = hostnoport;
  278.     }
  279. }
  280. tmp = pfs_enable; pfs_enable = PMAP_DISABLE;
  281. if((host = gethostbyname(hostname)) == NULL) {
  282.     pfs_enable = tmp;
  283.     /* Check if a numeric address */
  284.     newhostaddr = inet_addr(hostname);
  285.     if(newhostaddr == -1) {
  286. #ifdef DEBUG
  287. if (pfs_debug)
  288.   fprintf(stderr, "dirsrv: Can't resolve host %sn",hostname);
  289. #endif
  290. perrno = DIRSEND_BAD_HOSTNAME;
  291. ptlfree(pkt);
  292. /* return(NULL); */
  293. return(-1);
  294.     }
  295.     bzero((char *)&to, S_AD_SZ);
  296.     to.sin_family = AF_INET;
  297.     bcopy((char *)&newhostaddr, (char *)&to.sin_addr, 4);
  298.     if(hostaddr) bcopy((char *)&to, (char *)hostaddr, S_AD_SZ);
  299. }
  300. else {
  301.     pfs_enable = tmp;
  302.     bzero((char *)&to, S_AD_SZ);
  303.     to.sin_family = host->h_addrtype;
  304.     bcopy((char *)host->h_addr, (char *)&to.sin_addr, host->h_length);
  305.     if(hostaddr) bcopy((char *)&to, (char *)hostaddr, S_AD_SZ);
  306. }
  307.     }
  308.     else bcopy((char *)hostaddr, (char *)&to, S_AD_SZ);
  309.     /* lmjm: Save away the hostname */
  310.     strncpy(to_hostname, inet_ntoa(to.sin_addr), sizeof(to_hostname)-1);
  311.     if(req_udp_port) to.sin_port = htons(req_udp_port);
  312.     else to.sin_port = dir_udp_port;
  314.     /* If a port was specified in hostaddr, use it, otherwise fill it in */
  315.     if(hostaddr) {
  316. if(hostaddr->sin_port) to.sin_port = hostaddr->sin_port;
  317. else hostaddr->sin_port = to.sin_port;
  318.     }
  320.     /* Must open a new port each time. we do not want to see old */
  321.     /* responses to messages we are done with                    */
  322.     if ((lp = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  323. #ifdef DEBUG
  324.         if (pfs_debug)
  325.             fprintf(stderr,"dirsrv: Can't open socketn");
  326. #endif
  327. perrno = DIRSEND_UDP_CANT;
  328. ptlfree(pkt);
  329.         /* return(NULL); */
  330. return(-1);
  331.     }
  333.     /* Try to bind it to a privileged port - loop through candidate */
  334.     /* ports trying to bind.  If failed, that's OK, we will let the */
  335.     /* system assign a non-privileged port later                    */
  336.     if(!notprived) {
  337. for(tmp = PROS_FIRST_PRIVP; tmp < PROS_FIRST_PRIVP+PROS_NUM_PRIVP; 
  338.     tmp++) {
  339.     bzero((char *)&us, sizeof(us));
  340.     us.sin_family = AF_INET;
  341.     us.sin_port = htons((u_short) tmp);
  342.     if (bind(lp, (struct sockaddr *)&us, sizeof(us))) {
  343. if(errno != EADDRINUSE) {
  344.     notprived++;
  345.     break;
  346. }
  347.     }
  348.     else break;
  349. }
  350.     }
  352. #ifndef USE_V3_PROT
  353.     /* Add header */
  354.     if(rdgram_priority) {
  355. pkt->start -= 15;
  356. pkt->length += 15;
  357. *(pkt->start) = (char) 15;
  358. bzero(pkt->start+9,4);
  359. *(pkt->start+11) = 0x02;
  360. bcopy((char *)&priority, pkt->start+13,2);
  361.     }
  362.     else {
  363. pkt->start -= 9;
  364. pkt->length += 9;
  365. *(pkt->start) = (char) 9;
  366.     }
  367.     this_conn_id = htons(next_conn_id++);
  368.     if(next_conn_id == 0) next_conn_id++;
  369.     bcopy((char *)&this_conn_id, pkt->start+1,2);
  370.     bcopy((char *)&one,pkt->start+3,2);
  371.     bcopy((char *)&one,pkt->start+5,2);
  372.     bzero(pkt->start+7,2);
  373. #endif
  375. #ifdef DEBUG
  376.     if (pfs_debug > 2) {
  377. #ifndef USE_V3_PROT
  378.         if (to.sin_family == AF_INET) {
  379.     if(req_udp_port) 
  380. fprintf(stderr,"Sending message to %s+%d(%d)...",
  381. to_hostname, req_udp_port, ntohs(this_conn_id));
  382.     else fprintf(stderr,"Sending message to %s(%d)...",
  383.  to_hostname, ntohs(this_conn_id));
  384. }
  385. #else
  386.         if (to.sin_family == AF_INET) 
  387.     fprintf(stderr,"Sending message to %s...", to_hostname);
  388. #endif /* USE_V3_PROT */
  389.         else
  390.             fprintf(stderr,"Sending message...");
  391.         (void) fflush(stderr);
  392.     }
  393. #endif /* DEBUG */
  395.     first = ptalloc();
  396.     next = first;
  398.     return(lp);
  399. }
  401. /* - - - - - - - - */
  402. /*
  403.  * This used to be a label to goto to retry the last packet. Now we resend
  404.  * the packet and call keepWaitingDirsend() to wait for a reply. (We
  405.  * call keepWaitingDirsend() because formerly the code dropped through
  406.  * the keep_waiting label.)
  407.  */
  408. static void
  409. retryDirsend()
  410. {
  411.     gaps = ackpend = 0;
  414.     ns = sendto(lp,(char *)(pkt->start), pkt->length, 0, (struct sockaddr *)&to, S_AD_SZ);
  416.     if(ns != pkt->length) {
  417. #ifdef DEBUG
  418. if (pfs_debug) {
  419.     fprintf(stderr,"nsent only %d/%d: ",ns, pkt->length);
  420.     perror("");
  421. }
  422. #endif
  423. close(lp);
  424. perrno = DIRSEND_NOT_ALL_SENT;
  425. ptlfree(first);
  426. ptlfree(pkt);
  427. /* pkt= NULL;    */  /* added by NEC NWSL */
  428. /* return(NULL); */
  429. dirsendReturn = NULL;
  430. dirsendDone = DSRET_SEND_ERROR;
  431.     }
  432. #ifdef DEBUG
  433.     if (pfs_debug > 2) fprintf(stderr,"Sent.n");
  434. #endif
  435.     keepWaitingDirsend();
  436. }
  438. /* - - - - - - - - */
  439. /*
  440.  * This used to be a label to goto to set the appropriate timeout value
  441.  * and blocked in select(). Now we set selwait and the SELECTARGs to the
  442.  * appropriate values, and in X register a new timeout, then return to
  443.  * allow event processing.
  444.  */
  445. static void
  446. keepWaitingDirsend()
  447. {
  448.     /* We come back to this point (by a goto) if the packet */
  449.     /* received is only part of the response, or if the     */
  450.     /* response came from the wrong host     */
  452. #ifdef DEBUG
  453.     if (pfs_debug > 2) fprintf(stderr,"Waiting for reply...");
  454. #endif
  456.     FD_ZERO(&readfds);
  457.     FD_SET(lp, &readfds);
  459.     if(ackpend) selwait = &ackwait;
  460.     else if(gaps) selwait = &gapwait;
  461.     else selwait = &timeout;
  462. }
  464. /* - - - - - - - - */
  465. /*
  466.  * This routine is called when a timeout occurs. It includes the code that
  467.  * was formerly used when select() returned 0 (indicating a timeout).
  468.  */
  469. /*ARGSUSED*/
  470. static void
  471. timeoutProc(client_data,id)
  472. XtPointer client_data;
  473. XtIntervalId *id;
  474. {
  475.     if (gaps || ackpend) { /* Send acknowledgment */
  476. /* Acks are piggybacked on retries - If we have received */
  477. /* an ack from the server, then the packet sent is only  */
  478. /* an ack and the rest of the message will be empty      */
  479. #ifdef DEBUG
  480. if (pfs_debug > 2) {
  481.             fprintf(stderr,"Acknowledging (%s).n",
  482.     (ackpend ? "requested" : "gaps"));
  483. }
  484. #endif
  485. if (gaps && verbose)
  486.   fprintf (stderr, "Searching...n");
  487. retryDirsend();
  488. return;
  489.     }
  491.     if (retries-- > 0) {
  492. timeout.tv_sec = CLIENT_DIRSRV_BACKOFF(timeout.tv_sec);
  493. #ifdef DEBUG
  494. if (pfs_debug > 2) {
  495.             fprintf(stderr,"Timed out.  Setting timeout to %d seconds.n", 
  496.     (int)timeout.tv_sec);
  497. }
  498. #endif
  499. retryDirsend();
  500. return;
  501.     }
  503. #ifdef DEBUG
  504.     if (pfs_debug) {
  505. fprintf(stderr, "select failed(timeoutProc): readfds=%x ",
  506. *(int *)&readfds);
  507. perror("");
  508.     }
  509. #endif
  511.     close(lp);
  513.     perrno = DIRSEND_SELECT_FAILED;
  514.     ptlfree(first);
  515.     ptlfree(pkt);
  516.     /* return(NULL); */
  517.     dirsendReturn = NULL;
  518.     dirsendDone = DSRET_TIMEOUT;
  519. }
  521. /* - - - - - - - - */
  522. /*
  523.  * This function is called whenever there's something to read on the
  524.  * connection. It includes the code that was run when select() returned
  525.  * greater than 0 (indicating read ready).
  526.  */
  527. /*ARGSUSED*/
  528. static void
  529. readProc(client_data,source,id)
  530. XtPointer client_data;
  531. int *source;
  532. XtInputId *id;
  533. {
  534.     from_sz = sizeof(from);
  535.     next->start = next->dat;
  537.     if ((nr = recvfrom(lp, next->start, sizeof(next->dat), 0, (struct sockaddr *)&from, &from_sz)) < 0) {
  539. #ifdef DEBUG
  540.         if (pfs_debug) perror("recvfrom");
  541. #endif
  543. close(lp);
  545. perrno = DIRSEND_BAD_RECV;
  546. ptlfree(first);
  547. ptlfree(pkt);
  548. /* return(NULL) */
  549. dirsendReturn = NULL;
  550. dirsendDone = DSRET_RECV_ERROR;
  551.         return;
  552.     }
  554.     next->length = nr;
  555.     next->start[next->length] = 0;
  557. #ifdef DEBUG
  558.     if (pfs_debug > 2)
  559.         fprintf(stderr,"Received packet from %sn", inet_ntoa(from.sin_addr));
  560. #endif
  563.     /* For the current format, if the first byte is less than             */
  564.     /* 20, then the first two bits are a version number and the next six  */
  565.     /* are the header length (including the first byte).                  */
  566.     if((hdr_len = (unsigned char) *(next->start)) < 20) {
  567. ctlptr = next->start + 1;
  568. next->seq = 0;
  569. if(hdr_len >= 3) {  /* Connection ID */
  570.     bcopy(ctlptr, (char *)&stmp,2);
  571.     if(stmp) pkt_cid = ntohs(stmp);
  572.     ctlptr += 2;
  573. }
  574. if (pkt_cid<0)
  575.   pkt_cid = 65536+pkt_cid;
  576. if(pkt_cid && this_conn_id && (pkt_cid != ntohs(this_conn_id))) {
  577.     /* The packet is not for us */
  578.     /* goto keep_waiting; */
  579. #ifdef DEBUG
  580.   if (pfs_debug > 20)
  581.     fprintf(stderr,"Packet not for us %d,%d,%dn",
  582.     pkt_cid,this_conn_id,ntohs(this_conn_id));
  583. #endif
  584.     keepWaitingDirsend();
  585.     return;
  586. }
  587. if(hdr_len >= 5) { /* Packet number */
  588.     bcopy(ctlptr, (char *)&stmp,2);
  589.     next->seq = ntohs(stmp);
  590.     ctlptr += 2;
  591. }
  592. else { /* No packet number specified, so this is the only one */
  593.     next->seq = 1;
  594.     nd_pkts = 1;
  595. }
  596. if(hdr_len >= 7) {     /* Total number of packets */
  597.     bcopy(ctlptr, (char *)&stmp,2);  /* 0 means don't know      */
  598.     if(stmp) nd_pkts = ntohs(stmp);
  599.     ctlptr += 2;
  600. }
  601. if(hdr_len >= 9) { /* Receievd through */
  602.     bcopy(ctlptr, (char *)&stmp,2);  /* 1 means received request */
  603. #ifndef USE_V3_PROT
  604.     if((stmp) && (ntohs(stmp) == 1)) {
  605. /* Future retries will be acks only */
  606. pkt->length = 9;
  607. bcopy((char *)&zero, pkt->start+3,2);
  608. #ifdef DEBUG
  609. if(pfs_debug > 2) 
  610.     fprintf(stderr,"Server acked request - retries will be acks onlyn");
  611. #endif
  612.     }
  613. #endif
  614.     ctlptr += 2;
  615. }
  616. if(hdr_len >= 11) { /* Backoff */
  617.     bcopy(ctlptr, (char *)&stmp,2);
  618.     if(stmp) {
  619. backoff = (short) ntohs(stmp);
  620. #ifdef DEBUG
  621. if(pfs_debug > 2) 
  622.     fprintf(stderr,"Backing off to %d secondsn", backoff);
  623. #endif
  624. timeout.tv_sec = backoff;
  625. if ((backoff > 60) && (first == next) && (no_pkts == 0)) {
  626.     /* Probably a long queue on the server - don't give up */
  627.     retries = client_dirsrv_retry;
  628. }
  629.     }
  630.     ctlptr += 2;
  631. }
  632. if(hdr_len >= 12) { /* Flags (1st byte) */
  633.     bcopy(ctlptr, (char *)&rdflag11,1);
  634.     if(rdflag11 & 0x80) {
  635. #ifdef DEBUG
  636. if(pfs_debug > 2) 
  637.     fprintf(stderr,"Ack requestedn");
  638. #endif
  639. ackpend++;
  640.     }
  641.     if(rdflag11 & 0x40) {
  642. #ifdef DEBUG
  643. if(pfs_debug > 2) 
  644.     fprintf(stderr,"Sequenced control packetn");
  645. #endif
  646. next->length = -1;
  647. scpflag++;
  648.     }
  649.     ctlptr += 1;
  650. }
  651. if(hdr_len >= 13) { /* Flags (2nd byte) */
  652.     /* Reserved for future use */
  653.     bcopy(ctlptr, (char *)&rdflag12,1);
  654.     ctlptr += 1;
  655. }
  656. if(next->seq == 0) {
  657.     /* goto keep_waiting; */
  658.     keepWaitingDirsend();
  659.     return;
  660. }
  661. if(next->length >= 0) next->length -= hdr_len;
  662. next->start += hdr_len;
  663. goto done_old;
  664.     }
  666.     pkt_cid = 0;
  668.     /* if intermediate format (between old and new), then process */
  669.     /* and go to done_old                                         */
  670.     ctlptr = next->start + max(0,next->length-20);
  671.     while(*ctlptr) ctlptr++;
  672.     /* Control fields start after the terminating null */
  673.     ctlptr++;
  674.     /* Until old version are gone, must be 4 extra bytes minimum */
  675.     /* When no version 3 servers, can remove the -4              */
  676.     if(ctlptr < (next->start + next->length - 4)) {
  677. /* Connection ID */
  678. bcopy(ctlptr, (char *)&stmp,2);
  679. if(stmp) pkt_cid = ntohs(stmp);
  680. ctlptr += 2;
  681. if(pkt_cid && this_conn_id && (pkt_cid != ntohs(this_conn_id))) {
  682.     /* The packet is not for us */
  683.     /* goto keep_waiting; */
  684.     keepWaitingDirsend();
  685.     return;
  686. }
  687. /* Packet number */
  688. if(ctlptr < (next->start + next->length)) {
  689.     bcopy(ctlptr, (char *)&stmp,2);
  690.     next->seq = ntohs(stmp);
  691.     ctlptr += 2;
  692. }
  693. /* Total number of packets */
  694. if(ctlptr < (next->start + next->length)) {
  695.     bcopy(ctlptr, (char *)&stmp,2);
  696.     if(stmp) nd_pkts = ntohs(stmp);
  697.     ctlptr += 2;
  698. }
  699. /* Receievd through */
  700. if(ctlptr < (next->start + next->length)) {
  701.     /* Not supported by clients */
  702.     ctlptr += 2;
  703. }
  704. /* Backoff */
  705. if(ctlptr < (next->start + next->length)) {
  706.     bcopy(ctlptr, (char *)&stmp,2);
  707.     backoff = ntohs(stmp);
  708. #ifdef DEBUG
  709.     if(pfs_debug > 2) 
  710. fprintf(stderr,"Backing off to %d secondsn", backoff);
  711. #endif
  712.     if (verbose && backoff)
  713.       fprintf (stderr, "Searching...n");
  714.     if(backoff) timeout.tv_sec = backoff;
  715.     ctlptr += 2;
  716. }
  717. if(next->seq == 0) {
  718.     /* goto keep_waiting; */
  719.     keepWaitingDirsend();
  720.     return;
  721. }
  722. goto done_old;
  724.     }
  726.     /* Notes that we have to start searching 11 bytes before the    */
  727.     /* expected start of the MULTI-PACKET line because the message  */
  728.     /* might include up to 10 bytes of data after the trailing null */
  729.     /* The order of those bytes is two bytes each for Connection ID */
  730.     /* Packet-no, of, Received-through, Backoff                     */
  731.     seqtxt = nlsindex(next->start + max(0,next->length - 40),"MULTI-PACKET"); 
  732.     if(seqtxt) seqtxt+= 13;
  734.     if((nd_pkts == 0) && (no_pkts == 0) && (seqtxt == NULL)) goto all_done;
  736.     tmp = sscanf(seqtxt,"%d OF %d", &(next->seq), &nd_pkts);
  737. #ifdef DEBUG    
  738.     if (pfs_debug && (tmp == 0)) 
  739. fprintf(stderr,"Cant read packet sequence number: %s", seqtxt);    
  740. #endif
  741.  done_old:
  742. #ifdef DEBUG
  743.     if(pfs_debug > 2) fprintf(stderr,"Packet %d of %dn",next->seq,nd_pkts);
  744. #endif
  745.     if ((first == next) && (no_pkts == 0)) {
  746. if(first->seq == 1) {
  747.     comp_thru = first;
  748.     /* If only one packet, then return it */
  749.     if(nd_pkts == 1) goto all_done;
  750. }
  751. else gaps++;
  752. no_pkts = 1;
  753. next = ptalloc();
  754. /* goto keep_waiting; */
  755. keepWaitingDirsend();
  756. return;
  757.     }
  759.     if(comp_thru && (next->seq <= comp_thru->seq))
  760. ptfree(next);
  761.     else if (next->seq < first->seq) {
  762. vtmp = first;
  763. first = next;
  764. first->next = vtmp;
  765. first->previous = NULL;
  766. vtmp->previous = first;
  767. if(first->seq == 1) comp_thru = first;
  768. no_pkts++;
  769.     }
  770.     else {
  771. vtmp = (comp_thru ? comp_thru : first);
  772. while (vtmp->seq < next->seq) {
  773.     if(vtmp->next == NULL) {
  774. vtmp->next = next;
  775. next->previous = vtmp;
  776. next->next = NULL;
  777. no_pkts++;
  778. goto ins_done;
  779.     }
  780.     vtmp = vtmp->next;
  781. }
  782. if(vtmp->seq == next->seq)
  783.     ptfree(next);
  784. else {
  785.     vtmp->previous->next = next;
  786.     next->previous = vtmp->previous;
  787.     next->next = vtmp;
  788.     vtmp->previous = next;
  789.     no_pkts++;
  790. }
  791.     }   
  793. ins_done:
  795.     while(comp_thru && comp_thru->next && 
  796.   (comp_thru->next->seq == (comp_thru->seq + 1))) {
  797. comp_thru = comp_thru->next;
  798. #ifndef USE_V3_PROT
  799. recvd_thru = htons(comp_thru->seq);
  800. bcopy((char *)&recvd_thru,pkt->start+7,2); /* Let server know we got it */
  801. #endif
  802. /* We've made progress, so reset retry count */
  803. retries = client_dirsrv_retry;
  804. /* Also, next retry will be only an acknowledgement */
  805. /* but for now, we can't fill in the ack field      */
  806. #ifdef DEBUG
  807. if(pfs_debug > 2) 
  808.     fprintf(stderr,"Packets now received through %dn",comp_thru->seq);
  809. #endif
  810.     }
  812.     /* See if there are any gaps */
  813.     if(!comp_thru || comp_thru->next) gaps++;
  814.     else gaps = 0;
  816.     if ((nd_pkts == 0) || (no_pkts < nd_pkts)) {
  817. next = ptalloc();
  818. /* goto keep_waiting; */
  819. keepWaitingDirsend();
  820. return;
  821.     }
  823.  all_done:
  824.     if(ackpend) { /* Send acknowledgement if requested */
  825. #ifdef DEBUG
  826. if (pfs_debug > 2) {
  827.     if (to.sin_family == AF_INET)
  828. fprintf(stderr,"Acknowledging final packet to %s(%d)n",
  829. to_hostname, ntohs(this_conn_id));
  830.             else
  831.                 fprintf(stderr,"Acknowledging final packetn");
  832.     (void) fflush(stderr);
  833. }
  834. #endif
  836. ns = sendto(lp,(char *)(pkt->start), pkt->length, 0, (struct sockaddr *)&to, S_AD_SZ);
  838. if(ns != pkt->length) {
  839. #ifdef DEBUG
  840.     if (pfs_debug) {
  841. fprintf(stderr,"nsent only %d/%d: ",ns, pkt->length);
  842. perror("");
  843.     }
  844. #endif
  845. }
  847.     }
  849.     close(lp);
  851.     ptlfree(pkt);
  853.     /* Get rid of any sequenced control packets */
  854.     if(scpflag) {
  855. while(first && (first->length < 0)) {
  856.     vtmp = first;
  857.     first = first->next;
  858.     if(first) first->previous = NULL;
  859.     ptfree(vtmp);
  860. }
  861. vtmp = first;
  862. while(vtmp && vtmp->next) {
  863.     if(vtmp->next->length < 0) {
  864. if(vtmp->next->next) {
  865.     vtmp->next = vtmp->next->next;
  866.     ptfree(vtmp->next->previous);
  867.     vtmp->next->previous = vtmp;
  868. }
  869. else {
  870.     ptfree(vtmp->next);
  871.     vtmp->next = NULL;
  872. }
  873.     }
  874.     vtmp = vtmp->next;
  875. }
  876.     }
  878.     /* return(first); */
  879.     dirsendReturn = first;
  880.     dirsendDone = DSRET_DONE;
  882. }
  884. static void
  885. processEvent()
  886. {
  887.     /* select - either recv is ready, or timeout */
  888.     /* see if timeout or error or wrong descriptor */
  889.     tmp = select(lp + 1, &readfds, (SELECTARG *)0, (SELECTARG *)0, selwait);
  890.     if (tmp == 0) {
  891. timeoutProc(NULL,&timerId);
  892.     } else if ((tmp < 0) || !FD_ISSET(lp,&readfds)) {
  893. #ifdef DEBUG
  894. if (pfs_debug) {
  895.     fprintf(stderr, "select failed(processEvent): readfds=%x ",
  896.     *(int *)&readfds);
  897.     perror("");
  898. }
  899. #endif
  900. close(lp);
  902. perrno = DIRSEND_SELECT_FAILED;
  903. ptlfree(first);
  904. ptlfree(pkt);
  905. /* return(NULL); */
  906. dirsendReturn = NULL;
  907. dirsendDone = DSRET_SELECT_ERROR;
  908.     } else {
  909. readProc(NULL,&lp,&inputId);
  910.     }
  911. }
  913. void
  914. abortDirsend()
  915. {
  916.     if (!dirsendDone) {
  917. close(lp);
  919. ptlfree(first);
  920. ptlfree(pkt);
  921. dirsendReturn = NULL;
  922. dirsendDone = DSRET_ABORTED;
  923.     }
  924.     return;
  925. }