LCOV - code coverage report
Current view: top level - src - asfd.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 120 331 36.3 %
Date: 2017-03-02 Functions: 18 39 46.2 %

          Line data    Source code
       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "asfd.h"
       4             : #include "async.h"
       5             : #include "cmd.h"
       6             : #include "fsops.h"
       7             : #include "handy.h"
       8             : #include "iobuf.h"
       9             : #include "log.h"
      10             : #include "server/protocol2/champ_chooser/incoming.h"
      11             : 
      12             : // For IPTOS / IPTOS_THROUGHPUT.
      13             : #ifdef HAVE_WIN32
      14             : #include <ws2tcpip.h>
      15             : #else
      16             : #include <netinet/ip.h>
      17             : #endif
      18             : 
      19             : #ifdef HAVE_NCURSES_H
      20             : #include <ncurses.h>
      21             : #elif HAVE_NCURSES_NCURSES_H
      22             : #include <ncurses/ncurses.h>
      23             : #endif
      24             : 
      25             : #include "protocol2/blist.h"
      26             : 
      27             : static size_t bufmaxsize=(ASYNC_BUF_LEN*2)+32;
      28             : 
      29             : static void truncate_readbuf(struct asfd *asfd)
      30             : {
      31           0 :         asfd->readbuf[0]='\0';
      32           0 :         asfd->readbuflen=0;
      33             : }
      34             : 
      35          18 : static int asfd_alloc_buf(char **buf)
      36             : {
      37          18 :         if(!*buf && !(*buf=(char *)calloc_w(1, bufmaxsize, __func__)))
      38             :                 return -1;
      39             :         return 0;
      40             : }
      41             : 
      42           0 : static int extract_buf(struct asfd *asfd,
      43             :         unsigned int len, unsigned int offset)
      44             : {
      45           0 :         if(!(asfd->rbuf->buf=(char *)malloc_w(len+1, __func__)))
      46             :                 return -1;
      47           0 :         if(!(memcpy(asfd->rbuf->buf, asfd->readbuf+offset, len)))
      48             :         {
      49           0 :                 logp("%s: memcpy failed in %s\n", asfd->desc, __func__);
      50           0 :                 return -1;
      51             :         }
      52           0 :         asfd->rbuf->buf[len]='\0';
      53           0 :         if(!(memmove(asfd->readbuf,
      54           0 :                 asfd->readbuf+len+offset, asfd->readbuflen-len-offset)))
      55             :         {
      56           0 :                 logp("%s: memmove failed in %s\n", asfd->desc, __func__);
      57           0 :                 return -1;
      58             :         }
      59           0 :         asfd->readbuflen-=len+offset;
      60           0 :         asfd->rbuf->len=len;
      61           0 :         return 0;
      62             : }
      63             : 
      64             : #ifdef HAVE_NCURSES
      65           0 : static int parse_readbuf_ncurses(struct asfd *asfd)
      66             : {
      67           0 :         if(!asfd->readbuflen) return 0;
      68             :         // This is reading ints, and will be cast back to an int when it comes
      69             :         // to be processed later.
      70           0 :         if(extract_buf(asfd, asfd->readbuflen, 0)) return -1;
      71           0 :         return 0;
      72             : }
      73             : #endif
      74             : 
      75           0 : static int parse_readbuf_line_buf(struct asfd *asfd)
      76             : {
      77             :         static char *cp=NULL;
      78             :         static char *dp=NULL;
      79             :         static size_t len=0;
      80           0 :         if(!cp)
      81             :         {
      82             :                 // Only start from the beginning if we previously got something
      83             :                 // to extract.
      84           0 :                 cp=asfd->readbuf;
      85           0 :                 len=0;
      86             :         }
      87           0 :         for(; len<asfd->readbuflen; cp++, len++)
      88             :         {
      89           0 :                 if(*cp!='\n') continue;
      90           0 :                 len++;
      91           0 :                 if(extract_buf(asfd, len, 0)) return -1;
      92             :                 // Strip trailing white space, like '\r\n'.
      93           0 :                 dp=asfd->rbuf->buf;
      94           0 :                 for(cp=&(dp[len-1]); cp>=dp && isspace(*cp); cp--, len--)
      95           0 :                         *cp='\0';
      96           0 :                 asfd->rbuf->len=len;
      97           0 :                 break;
      98             :         }
      99           0 :         cp=NULL;
     100           0 :         return 0;
     101             : }
     102             : 
     103           0 : static int parse_readbuf_standard(struct asfd *asfd)
     104             : {
     105           0 :         enum cmd cmdtmp=CMD_ERROR;
     106           0 :         unsigned int s=0;
     107           0 :         if(asfd->readbuflen<5) return 0;
     108           0 :         if((sscanf(asfd->readbuf, "%c%04X", (char *)&cmdtmp, &s))!=2)
     109             :         {
     110           0 :                 logp("%s: sscanf of '%s' failed in %s\n",
     111             :                         asfd->desc, asfd->readbuf, __func__);
     112           0 :                 return -1;
     113             :         }
     114           0 :         if(asfd->readbuflen>=s+5)
     115             :         {
     116           0 :                 asfd->rbuf->cmd=cmdtmp;
     117           0 :                 if(extract_buf(asfd, s, 5))
     118             :                         return -1;
     119             :         }
     120             :         return 0;
     121             : }
     122             : 
     123           0 : static int asfd_parse_readbuf(struct asfd *asfd)
     124             : {
     125           0 :         if(asfd->rbuf->buf) return 0;
     126             : 
     127           0 :         if(asfd->parse_readbuf_specific(asfd))
     128             :         {
     129           0 :                 truncate_readbuf(asfd);
     130           0 :                 return -1;
     131             :         }
     132             : 
     133             :         return 0;
     134             : }
     135             : 
     136             : #ifdef HAVE_NCURSES
     137           0 : static int asfd_do_read_ncurses(struct asfd *asfd)
     138             : {
     139             :         static int i;
     140           0 :         i=getch();
     141           0 :         asfd->readbuflen=sizeof(int);
     142           0 :         memcpy(asfd->readbuf, &i, asfd->readbuflen);
     143           0 :         return 0;
     144             : }
     145             : 
     146           0 : static int asfd_do_write_ncurses(__attribute__ ((unused)) struct asfd *asfd)
     147             : {
     148           0 :         logp("This function should not have been called: %s\n", __func__);
     149           0 :         return -1;
     150             : }
     151             : #endif
     152             : 
     153           0 : static int asfd_do_read(struct asfd *asfd)
     154             : {
     155             :         ssize_t r;
     156           0 :         r=read(asfd->fd,
     157           0 :                 asfd->readbuf+asfd->readbuflen, bufmaxsize-asfd->readbuflen);
     158           0 :         if(r<0)
     159             :         {
     160           0 :                 if(errno==EAGAIN || errno==EINTR)
     161             :                         return 0;
     162           0 :                 logp("%s: read problem on fd %d: %s\n",
     163             :                         asfd->desc, asfd->fd, strerror(errno));
     164           0 :                 goto error;
     165             :         }
     166           0 :         else if(!r)
     167             :         {
     168             :                 // End of data.
     169           0 :                 logp("%s: end of data\n", asfd->desc);
     170           0 :                 goto error;
     171             :         }
     172           0 :         asfd->readbuflen+=r;
     173           0 :         asfd->rcvd+=r;
     174           0 :         return 0;
     175             : error:
     176           0 :         truncate_readbuf(asfd);
     177           0 :         return -1;
     178             : }
     179             : 
     180           0 : static int asfd_do_read_ssl(struct asfd *asfd)
     181             : {
     182             :         int e;
     183             :         ssize_t r;
     184             : 
     185           0 :         asfd->read_blocked_on_write=0;
     186             : 
     187           0 :         ERR_clear_error();
     188           0 :         r=SSL_read(asfd->ssl,
     189           0 :                 asfd->readbuf+asfd->readbuflen, bufmaxsize-asfd->readbuflen);
     190             : 
     191           0 :         switch((e=SSL_get_error(asfd->ssl, r)))
     192             :         {
     193             :                 case SSL_ERROR_NONE:
     194           0 :                         asfd->readbuflen+=r;
     195           0 :                         asfd->readbuf[asfd->readbuflen]='\0';
     196           0 :                         asfd->rcvd+=r;
     197           0 :                         break;
     198             :                 case SSL_ERROR_ZERO_RETURN:
     199             :                         // End of data.
     200           0 :                         logp("%s: Peer closed SSL session\n", asfd->desc);
     201           0 :                         SSL_shutdown(asfd->ssl);
     202           0 :                         goto error;
     203             :                 case SSL_ERROR_WANT_READ:
     204             :                         break;
     205             :                 case SSL_ERROR_WANT_WRITE:
     206           0 :                         asfd->read_blocked_on_write=1;
     207           0 :                         break;
     208             :                 case SSL_ERROR_SYSCALL:
     209           0 :                         if(errno==EAGAIN || errno==EINTR)
     210             :                                 break;
     211           0 :                         logp("%s: Got SSL_ERROR_SYSCALL\n",
     212             :                                 asfd->desc);
     213             :                         // Fall through to read problem
     214             :                 default:
     215           0 :                         logp_ssl_err(
     216             :                                 "%s: SSL read problem in %s: %d - %d=%s\n",
     217             :                                 asfd->desc, __func__,
     218           0 :                                 e, errno, strerror(errno));
     219           0 :                         goto error;
     220             :         }
     221             :         return 0;
     222             : error:
     223           0 :         truncate_readbuf(asfd);
     224           0 :         return -1;
     225             : }
     226             : 
     227             : // Return 0 for OK to write, non-zero for not OK to write.
     228           0 : static int check_ratelimit(struct asfd *asfd)
     229             : {
     230             :         float f;
     231             :         time_t diff;
     232           0 :         if(!asfd->rlstart) asfd->rlstart=time(NULL);
     233           0 :         if((diff=asfd->as->now-asfd->rlstart)<0)
     234             :         {
     235             :                 // It is possible that the clock changed. Reset ourselves.
     236           0 :                 asfd->as->now=asfd->rlstart;
     237           0 :                 asfd->rlbytes=0;
     238           0 :                 logp("Looks like the clock went back in time since starting. "
     239             :                         "Resetting ratelimit\n");
     240           0 :                 return 0;
     241             :         }
     242           0 :         if(!diff) return 0; // Need to get started somehow.
     243           0 :         f=(asfd->rlbytes)/diff; // Bytes per second.
     244             : 
     245           0 :         if(f>=asfd->ratelimit)
     246             :         {
     247             : #ifdef HAVE_WIN32
     248             :                 // Windows Sleep is milliseconds, usleep is microseconds.
     249             :                 // Do some conversion.
     250             :                 Sleep(asfd->rlsleeptime/1000);
     251             : #else
     252           0 :                 usleep(asfd->rlsleeptime);
     253             : #endif
     254             :                 // If sleeping, increase the sleep time.
     255           0 :                 if((asfd->rlsleeptime*=2)>=500000) asfd->rlsleeptime=500000;
     256             :                 return 1;
     257             :         }
     258             :         // If not sleeping, decrease the sleep time.
     259           0 :         if((asfd->rlsleeptime/=2)<=9999) asfd->rlsleeptime=10000;
     260             :         return 0;
     261             : }
     262             : 
     263           0 : static int asfd_do_write(struct asfd *asfd)
     264             : {
     265             :         ssize_t w;
     266           0 :         if(asfd->ratelimit && check_ratelimit(asfd)) return 0;
     267             : 
     268           0 :         w=write(asfd->fd, asfd->writebuf, asfd->writebuflen);
     269           0 :         if(w<0)
     270             :         {
     271           0 :                 if(errno==EAGAIN || errno==EINTR)
     272             :                         return 0;
     273           0 :                 logp("%s: Got error in %s, (%d=%s)\n", __func__,
     274             :                         asfd->desc, errno, strerror(errno));
     275           0 :                 return -1;
     276             :         }
     277           0 :         else if(!w)
     278             :         {
     279           0 :                 logp("%s: Wrote nothing in %s\n", asfd->desc, __func__);
     280           0 :                 return -1;
     281             :         }
     282           0 :         if(asfd->ratelimit) asfd->rlbytes+=w;
     283           0 :         asfd->sent+=w;
     284             : /*
     285             : {
     286             : char buf[100000]="";
     287             : snprintf(buf, w+1, "%s", asfd->writebuf);
     288             : printf("wrote %d: %s\n", w, buf);
     289             : }
     290             : */
     291             : 
     292           0 :         memmove(asfd->writebuf, asfd->writebuf+w, asfd->writebuflen-w);
     293           0 :         asfd->writebuflen-=w;
     294           0 :         return 0;
     295             : }
     296             : 
     297           0 : static int asfd_do_write_ssl(struct asfd *asfd)
     298             : {
     299             :         int e;
     300             :         ssize_t w;
     301             : 
     302           0 :         asfd->write_blocked_on_read=0;
     303             : 
     304           0 :         if(asfd->ratelimit && check_ratelimit(asfd)) return 0;
     305           0 :         ERR_clear_error();
     306           0 :         w=SSL_write(asfd->ssl, asfd->writebuf, asfd->writebuflen);
     307             : 
     308           0 :         switch((e=SSL_get_error(asfd->ssl, w)))
     309             :         {
     310             :                 case SSL_ERROR_NONE:
     311             : /*
     312             : {
     313             : char buf[100000]="";
     314             : snprintf(buf, w+1, "%s", asfd->writebuf);
     315             : printf("wrote %d: %s\n", w, buf);
     316             : }
     317             : */
     318           0 :                         if(asfd->ratelimit) asfd->rlbytes+=w;
     319           0 :                         memmove(asfd->writebuf,
     320           0 :                                 asfd->writebuf+w, asfd->writebuflen-w);
     321           0 :                         asfd->writebuflen-=w;
     322           0 :                         asfd->sent+=w;
     323           0 :                         break;
     324             :                 case SSL_ERROR_WANT_WRITE:
     325             :                         break;
     326             :                 case SSL_ERROR_WANT_READ:
     327           0 :                         asfd->write_blocked_on_read=1;
     328           0 :                         break;
     329             :                 case SSL_ERROR_SYSCALL:
     330           0 :                         if(errno==EAGAIN || errno==EINTR)
     331             :                                 break;
     332           0 :                         logp("%s: Got SSL_ERROR_SYSCALL\n",
     333             :                                 asfd->desc);
     334             :                         // Fall through to read problem
     335             :                 default:
     336           0 :                         logp_ssl_err(
     337             :                                 "%s: SSL write problem in %s: %d - %d=%s\n",
     338             :                                 asfd->desc, __func__,
     339           0 :                                 e, errno, strerror(errno));
     340           0 :                         return -1;
     341             :         }
     342             :         return 0;
     343             : }
     344             : 
     345           0 : static int append_to_write_buffer(struct asfd *asfd,
     346             :         const char *buf, size_t len)
     347             : {
     348           0 :         memcpy(asfd->writebuf+asfd->writebuflen, buf, len);
     349           0 :         asfd->writebuflen+=len;
     350           0 :         asfd->writebuf[asfd->writebuflen]='\0';
     351           0 :         return 0;
     352             : }
     353             : 
     354           0 : static enum append_ret asfd_append_all_to_write_buffer(struct asfd *asfd,
     355             :         struct iobuf *wbuf)
     356             : {
     357           0 :         switch(asfd->streamtype)
     358             :         {
     359             :                 case ASFD_STREAM_STANDARD:
     360             :                 {
     361           0 :                         size_t sblen=0;
     362           0 :                         char sbuf[10]="";
     363           0 :                         if(asfd->writebuflen+6+(wbuf->len) >= bufmaxsize-1)
     364           0 :                                 return APPEND_BLOCKED;
     365             : 
     366           0 :                         snprintf(sbuf, sizeof(sbuf), "%c%04X",
     367           0 :                                 wbuf->cmd, (unsigned int)wbuf->len);
     368           0 :                         sblen=strlen(sbuf);
     369           0 :                         append_to_write_buffer(asfd, sbuf, sblen);
     370           0 :                         break;
     371             :                 }
     372             :                 case ASFD_STREAM_LINEBUF:
     373           0 :                         if(asfd->writebuflen+wbuf->len >= bufmaxsize-1)
     374             :                                 return APPEND_BLOCKED;
     375             :                         break;
     376             :                 case ASFD_STREAM_NCURSES_STDIN:
     377             :                 default:
     378           0 :                         logp("%s: unknown asfd stream type in %s: %d\n",
     379             :                                 asfd->desc, __func__, asfd->streamtype);
     380           0 :                         return APPEND_ERROR;
     381             :         }
     382           0 :         append_to_write_buffer(asfd, wbuf->buf, wbuf->len);
     383             : //printf("append %d: %c:%s\n", wbuf->len, wbuf->cmd, wbuf->buf);
     384           0 :         wbuf->len=0;
     385           0 :         return APPEND_OK;
     386             : }
     387             : 
     388           0 : static int asfd_set_bulk_packets(struct asfd *asfd)
     389             : {
     390             : #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
     391           0 :         int opt=IPTOS_THROUGHPUT;
     392           0 :         if(asfd->fd<0) return -1;
     393           0 :         if(setsockopt(asfd->fd,
     394             :                 IPPROTO_IP, IP_TOS, (char *)&opt, sizeof(opt))<0)
     395             :         {
     396           0 :                 logp("%s: error: setsockopt IPTOS_THROUGHPUT: %s\n",
     397           0 :                         asfd->desc, strerror(errno));
     398           0 :                 return -1;
     399             :         }
     400             : #endif
     401             :         return 0;
     402             : }
     403             : 
     404           0 : static int asfd_read(struct asfd *asfd)
     405             : {
     406           0 :         if(asfd->as->doing_estimate) return 0;
     407           0 :         while(!asfd->rbuf->buf)
     408           0 :                 if(asfd->as->read_write(asfd->as)) return -1;
     409             :         return 0;
     410             : }
     411             : 
     412          95 : int asfd_read_expect(struct asfd *asfd, enum cmd cmd, const char *expect)
     413             : {
     414          95 :         int ret=0;
     415          95 :         if(asfd->read(asfd)) return -1;
     416          93 :         if(asfd->rbuf->cmd!=cmd || strcmp(asfd->rbuf->buf, expect))
     417             :         {
     418           4 :                 logp("%s: expected '%c:%s', got '%c:%s'\n",
     419             :                         asfd->desc, cmd, expect,
     420             :                         asfd->rbuf->cmd, asfd->rbuf->buf);
     421           4 :                 ret=-1;
     422             :         }
     423          93 :         iobuf_free_content(asfd->rbuf);
     424          93 :         return ret;
     425             : }
     426             : 
     427           0 : static int asfd_write(struct asfd *asfd, struct iobuf *wbuf)
     428             : {
     429           0 :         if(asfd->as->doing_estimate) return 0;
     430           0 :         while(wbuf->len)
     431             :         {
     432           0 :                 if(asfd->append_all_to_write_buffer(asfd, wbuf)==APPEND_ERROR)
     433             :                         return -1;
     434           0 :                 if(asfd->as->write(asfd->as)) return -1;
     435             :         }
     436             :         return 0;
     437             : }
     438             : 
     439           0 : static int asfd_write_str(struct asfd *asfd, enum cmd wcmd, const char *wsrc)
     440             : {
     441             :         struct iobuf wbuf;
     442           0 :         wbuf.cmd=wcmd;
     443           0 :         wbuf.buf=(char *)wsrc;
     444           0 :         wbuf.len=strlen(wsrc);
     445           0 :         return asfd->write(asfd, &wbuf);
     446             : }
     447             : 
     448             : #ifndef UTEST
     449             : static
     450             : #endif
     451          16 : int asfd_simple_loop(struct asfd *asfd,
     452             :         struct conf **confs, void *param, const char *caller,
     453             :   enum asl_ret callback(struct asfd *asfd, struct conf **confs, void *param))
     454             : {
     455          16 :         struct iobuf *rbuf=asfd->rbuf;
     456             :         while(1)
     457             :         {
     458         729 :                 iobuf_free_content(rbuf);
     459         729 :                 if(asfd->read(asfd)) goto error;
     460         728 :                 if(!rbuf->buf) continue;
     461          24 :                 if(rbuf->cmd!=CMD_GEN)
     462             :                 {
     463           0 :                         if(rbuf->cmd==CMD_WARNING
     464           0 :                           || rbuf->cmd==CMD_MESSAGE)
     465             :                         {
     466           0 :                                 struct cntr *cntr=NULL;
     467           0 :                                 if(confs) cntr=get_cntr(confs);
     468           0 :                                 log_recvd(rbuf, cntr, 0);
     469             :                         }
     470           0 :                         else if(rbuf->cmd==CMD_INTERRUPT)
     471             :                         {
     472             :                                 // Ignore - client wanted to interrupt a file.
     473             :                         }
     474             :                         else
     475             :                         {
     476           0 :                                 logp("%s: unexpected command in %s(), called from %s(): %c:%s\n", asfd->desc, __func__, caller, rbuf->cmd, rbuf->buf);
     477           0 :                                 goto error;
     478             :                         }
     479           0 :                         continue;
     480             :                 }
     481          24 :                 switch(callback(asfd, confs, param))
     482             :                 {
     483             :                         case ASL_CONTINUE: break;
     484             :                         case ASL_END_OK:
     485          13 :                                 iobuf_free_content(rbuf);
     486          13 :                                 return 0;
     487             :                         case ASL_END_OK_RETURN_1:
     488           0 :                                 iobuf_free_content(rbuf);
     489           0 :                                 return 1;
     490             :                         case ASL_END_ERROR:
     491             :                         default:
     492             :                                 goto error;
     493             :                 }
     494             :         }
     495             : error:
     496           3 :         iobuf_free_content(rbuf);
     497           3 :         return -1;
     498             : }
     499             : 
     500           0 : static void asfd_set_timeout(struct asfd *asfd, int max_network_timeout)
     501             : {
     502           0 :         asfd->max_network_timeout=max_network_timeout;
     503           0 :         asfd->network_timeout=asfd->max_network_timeout;
     504           0 : }
     505             : 
     506           9 : static int asfd_init(struct asfd *asfd, const char *desc,
     507             :         struct async *as, int afd, SSL *assl, enum asfd_streamtype streamtype)
     508             : {
     509           9 :         asfd->as=as;
     510           9 :         asfd->fd=afd;
     511           9 :         asfd->ssl=assl;
     512           9 :         asfd->streamtype=streamtype;
     513           9 :         asfd->rlsleeptime=10000;
     514           9 :         asfd->pid=-1;
     515           9 :         asfd->attempt_reads=1;
     516             : 
     517           9 :         asfd->parse_readbuf=asfd_parse_readbuf;
     518           9 :         asfd->append_all_to_write_buffer=asfd_append_all_to_write_buffer;
     519           9 :         asfd->set_bulk_packets=asfd_set_bulk_packets;
     520           9 :         asfd->set_timeout=asfd_set_timeout;
     521           9 :         if(asfd->ssl)
     522             :         {
     523           1 :                 asfd->do_read=asfd_do_read_ssl;
     524           1 :                 asfd->do_write=asfd_do_write_ssl;
     525             :         }
     526             :         else
     527             :         {
     528           8 :                 asfd->do_read=asfd_do_read;
     529           8 :                 asfd->do_write=asfd_do_write;
     530             : #ifdef HAVE_NCURSES
     531           8 :                 if(asfd->streamtype==ASFD_STREAM_NCURSES_STDIN)
     532             :                 {
     533           1 :                         asfd->do_read=asfd_do_read_ncurses;
     534           1 :                         asfd->do_write=asfd_do_write_ncurses;
     535             :                 }
     536             : #endif
     537             :         }
     538           9 :         asfd->read=asfd_read;
     539           9 :         asfd->simple_loop=asfd_simple_loop;
     540           9 :         asfd->write=asfd_write;
     541           9 :         asfd->write_str=asfd_write_str;
     542             : 
     543           9 :         switch(asfd->streamtype)
     544             :         {
     545             :                 case ASFD_STREAM_STANDARD:
     546           2 :                         asfd->parse_readbuf_specific=parse_readbuf_standard;
     547           2 :                         break;
     548             :                 case ASFD_STREAM_LINEBUF:
     549           6 :                         asfd->parse_readbuf_specific=parse_readbuf_line_buf;
     550           6 :                         break;
     551             : #ifdef HAVE_NCURSES
     552             :                 case ASFD_STREAM_NCURSES_STDIN:
     553           1 :                         asfd->parse_readbuf_specific=parse_readbuf_ncurses;
     554           1 :                         break;
     555             : #endif
     556             :                 default:
     557           0 :                         logp("%s: unknown asfd stream type in %s: %d\n",
     558             :                                 desc, __func__, asfd->streamtype);
     559           0 :                         return -1;
     560             :         }
     561             : 
     562           9 :         if(!(asfd->rbuf=iobuf_alloc())
     563           9 :           || asfd_alloc_buf(&asfd->readbuf)
     564           9 :           || asfd_alloc_buf(&asfd->writebuf)
     565           9 :           || !(asfd->desc=strdup_w(desc, __func__)))
     566             :                 return -1;
     567             :         return 0;
     568             : }
     569             : 
     570         350 : struct asfd *asfd_alloc(void)
     571             : {
     572         359 :         return (struct asfd *)calloc_w(1, sizeof(struct asfd), __func__);
     573             : }
     574             : 
     575         359 : void asfd_close(struct asfd *asfd)
     576             : {
     577         718 :         if(!asfd) return;
     578         359 :         if(asfd->ssl && asfd->fd>=0)
     579             :         {
     580           1 :                 set_blocking(asfd->fd);
     581             :                 // I do not think this SSL_shutdown stuff works right.
     582             :                 // Ignore it for now.
     583             : #ifndef HAVE_WIN32
     584           1 :                 signal(SIGPIPE, SIG_IGN);
     585             : #endif
     586           1 :                 if(!SSL_shutdown(asfd->ssl))
     587             :                 {
     588           0 :                         shutdown(asfd->fd, 1);
     589           0 :                         SSL_shutdown(asfd->ssl);
     590             :                 }
     591             :         }
     592         359 :         if(asfd->ssl)
     593             :         {
     594           1 :                 SSL_free(asfd->ssl);
     595           1 :                 asfd->ssl=NULL;
     596             :         }
     597         359 :         close_fd(&asfd->fd);
     598             : }
     599             : 
     600         359 : static void asfd_free_content(struct asfd *asfd)
     601             : {
     602         359 :         asfd_close(asfd);
     603         359 :         iobuf_free(&asfd->rbuf);
     604         359 :         free_w(&asfd->readbuf);
     605         359 :         free_w(&asfd->writebuf);
     606         359 :         free_w(&asfd->desc);
     607         359 :         incoming_free(&asfd->in);
     608         359 :         blist_free(&asfd->blist);
     609         359 : }
     610             : 
     611         361 : void asfd_free(struct asfd **asfd)
     612             : {
     613         722 :         if(!asfd || !*asfd) return;
     614         359 :         asfd_free_content(*asfd);
     615         359 :         free_v((void **)asfd);
     616             : }
     617             : 
     618          10 : static struct asfd *do_setup_asfd(struct async *as,
     619             :         const char *desc, int *fd, SSL *ssl, enum asfd_streamtype streamtype)
     620             : {
     621          10 :         struct asfd *asfd=NULL;
     622             : 
     623          10 :         if(!fd || *fd<0)
     624             :         {
     625           1 :                 logp("Given invalid descriptor in %s\n", __func__);
     626           1 :                 goto error;
     627             :         }
     628             : 
     629           9 :         set_non_blocking(*fd);
     630           9 :         if(!(asfd=asfd_alloc())
     631           9 :           || asfd_init(asfd, desc, as, *fd, ssl, streamtype))
     632             :                 goto error;
     633           9 :         *fd=-1;
     634           9 :         as->asfd_add(as, asfd);
     635           9 :         return asfd;
     636             : error:
     637           1 :         asfd_free(&asfd);
     638           1 :         return NULL;
     639             : }
     640             : 
     641           1 : struct asfd *setup_asfd_ssl(struct async *as,
     642             :         const char *desc, int *fd, SSL *ssl)
     643             : {
     644           1 :         return do_setup_asfd(as, desc, fd,
     645             :                 ssl, ASFD_STREAM_STANDARD);
     646             : }
     647             : 
     648           2 : struct asfd *setup_asfd(struct async *as,
     649             :         const char *desc, int *fd)
     650             : {
     651           2 :         return do_setup_asfd(as, desc, fd,
     652             :                 /*ssl=*/NULL, ASFD_STREAM_STANDARD);
     653             : }
     654             : 
     655             : static struct asfd *setup_asfd_linebuf(struct async *as,
     656             :         const char *desc, int *fd)
     657             : {
     658           6 :         return do_setup_asfd(as, desc, fd,
     659             :                 /*ssl=*/NULL, ASFD_STREAM_LINEBUF);
     660             : }
     661             : 
     662           1 : struct asfd *setup_asfd_linebuf_read(struct async *as,
     663             :         const char *desc, int *fd)
     664             : {
     665           1 :         return setup_asfd_linebuf(as, desc, fd);
     666             : }
     667             : 
     668           1 : struct asfd *setup_asfd_linebuf_write(struct async *as,
     669             :         const char *desc, int *fd)
     670             : {
     671             :         struct asfd *asfd;
     672           3 :         if((asfd=setup_asfd_linebuf(as, desc, fd)))
     673           3 :                 asfd->attempt_reads=0;
     674           1 :         return asfd;
     675             : }
     676             : 
     677           2 : struct asfd *setup_asfd_stdin(struct async *as)
     678             : {
     679           2 :         int fd=fileno(stdin);
     680           2 :         return setup_asfd_linebuf_read(as, "stdin", &fd);
     681             : }
     682             : 
     683           2 : struct asfd *setup_asfd_stdout(struct async *as)
     684             : {
     685           2 :         int fd=fileno(stdout);
     686           2 :         return setup_asfd_linebuf_write(as, "stdout", &fd);
     687             : }
     688             : 
     689           1 : struct asfd *setup_asfd_ncurses_stdin(struct async *as)
     690             : {
     691           1 :         int fd=fileno(stdin);
     692           1 :         return do_setup_asfd(as, "stdin", &fd,
     693             :                 /*ssl=*/NULL, ASFD_STREAM_NCURSES_STDIN);
     694             : }
     695             : 
     696             : // Want to make sure that we are listening for reads too - this will let us
     697             : // exit promptly if the client was killed.
     698           0 : static int read_and_write(struct asfd *asfd)
     699             : {
     700           0 :         if(asfd->as->read_write(asfd->as)) return -1;
     701           0 :         if(!asfd->rbuf->buf) return 0;
     702           0 :         iobuf_log_unexpected(asfd->rbuf, __func__);
     703             :         return -1;
     704             : }
     705             : 
     706           0 : int asfd_flush_asio(struct asfd *asfd)
     707             : {
     708           0 :         while(asfd && asfd->writebuflen>0)
     709           0 :                 if(read_and_write(asfd)) return -1;
     710             :         return 0;
     711             : }
     712             : 
     713          84 : int asfd_write_wrapper(struct asfd *asfd, struct iobuf *wbuf)
     714             : {
     715             :         while(1)
     716             :         {
     717          84 :                 switch(asfd->append_all_to_write_buffer(asfd, wbuf))
     718             :                 {
     719             :                         case APPEND_OK: return 0;
     720             :                         case APPEND_BLOCKED: break;
     721           3 :                         default: return -1;
     722             :                 }
     723           0 :                 if(read_and_write(asfd)) return -1;
     724             :         }
     725             :         return 0;
     726             : }
     727             : 
     728          84 : int asfd_write_wrapper_str(struct asfd *asfd, enum cmd wcmd, const char *wsrc)
     729             : {
     730             :         static struct iobuf wbuf;
     731          84 :         iobuf_from_str(&wbuf, wcmd, (char *)wsrc);
     732          84 :         return asfd_write_wrapper(asfd, &wbuf);
     733             : }
     734             : 

Generated by: LCOV version 1.10