LCOV - code coverage report
Current view: top level - src/server - extra_comms.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 226 262 86.3 %
Date: 2019-05-31 06:18:14 Functions: 10 11 90.9 %

          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 "../conf.h"
       7             : #include "../conffile.h"
       8             : #include "../fsops.h"
       9             : #include "../handy.h"
      10             : #include "../incexc_recv.h"
      11             : #include "../incexc_send.h"
      12             : #include "../iobuf.h"
      13             : #include "../log.h"
      14             : #include "../pathcmp.h"
      15             : #include "../prepend.h"
      16             : #include "autoupgrade.h"
      17             : #include "extra_comms.h"
      18             : 
      19             : #include <librsync.h>
      20             : 
      21         349 : static int append_to_feat(char **feat, const char *str)
      22             : {
      23         349 :         char *tmp=NULL;
      24         349 :         if(!*feat)
      25             :         {
      26          35 :                 if(!(*feat=strdup_w(str, __func__)))
      27             :                         return -1;
      28          35 :                 return 0;
      29             :         }
      30         314 :         if(!(tmp=prepend(*feat, str)))
      31             :                 return -1;
      32         314 :         free_w(feat);
      33         314 :         *feat=tmp;
      34         314 :         return 0;
      35             : }
      36             : 
      37             : // It is unfortunate that we are having to figure out the server-initiated
      38             : // restore paths here instead of setting it in a struct sdirs.
      39             : // But doing the extra_comms needs to come before setting the sdirs, because
      40             : // extra_comms sets up a bunch of settings that sdirs need to know.
      41          35 : static char *get_restorepath_proto1(struct conf **cconfs)
      42             : {
      43          35 :         char *tmp=NULL;
      44          35 :         char *restorepath=NULL;
      45          35 :         if((tmp=prepend_s(get_string(cconfs[OPT_DIRECTORY]),
      46          35 :                 get_string(cconfs[OPT_CNAME]))))
      47          35 :                         restorepath=prepend_s(tmp, "restore");
      48          35 :         free_w(&tmp);
      49          35 :         return restorepath;
      50             : }
      51             : 
      52          35 : static char *get_restorepath_proto2(struct conf **cconfs)
      53             : {
      54          35 :         char *tmp1=NULL;
      55          35 :         char *tmp2=NULL;
      56          35 :         char *restorepath=NULL;
      57          35 :         if(!(tmp1=prepend_s(get_string(cconfs[OPT_DIRECTORY]),
      58          35 :                 get_string(cconfs[OPT_DEDUP_GROUP]))))
      59             :                         goto error;
      60          35 :         if(!(tmp2=prepend_s(tmp1, "clients")))
      61             :                 goto error;
      62          35 :         free_w(&tmp1);
      63          35 :         if(!(tmp1=prepend_s(tmp2, get_string(cconfs[OPT_CNAME]))))
      64             :                 goto error;
      65          35 :         if(!(restorepath=prepend_s(tmp1, "restore")))
      66             :                 goto error;
      67             :         goto end;
      68             : error:
      69           0 :         free_w(&restorepath);
      70             : end:
      71          35 :         free_w(&tmp1);
      72          35 :         free_w(&tmp2);
      73          35 :         return restorepath;
      74             : }
      75             : 
      76          35 : static int set_restore_path(struct conf **cconfs, char **feat)
      77             : {
      78          35 :         int ret=-1;
      79          35 :         char *restorepath1=NULL;
      80          35 :         char *restorepath2=NULL;
      81          35 :         if(!(restorepath1=get_restorepath_proto1(cconfs))
      82          35 :           || !(restorepath2=get_restorepath_proto2(cconfs)))
      83             :                 goto end;
      84          35 :         if(is_reg_lstat(restorepath1)==1
      85           4 :           && set_string(cconfs[OPT_RESTORE_PATH], restorepath1))
      86             :                 goto end;
      87          35 :         else if(is_reg_lstat(restorepath2)==1
      88           0 :           && set_string(cconfs[OPT_RESTORE_PATH], restorepath2))
      89             :                 goto end;
      90          35 :         if(get_string(cconfs[OPT_RESTORE_PATH])
      91           4 :           && append_to_feat(feat, "srestore:"))
      92             :                 goto end;
      93             :         ret=0;
      94             : end:
      95          35 :         free_w(&restorepath1);
      96          35 :         free_w(&restorepath2);
      97          35 :         return ret;
      98             : }
      99             : 
     100             : struct vers
     101             : {
     102             :         long min;
     103             :         long cli;
     104             :         long ser;
     105             :         long feat_list;
     106             :         long directory_tree;
     107             :         long burp2;
     108             :         long counters_json;
     109             : };
     110             : 
     111          35 : static int send_features(struct asfd *asfd, struct conf **cconfs,
     112             :         struct vers *vers)
     113             : {
     114          35 :         int ret=-1;
     115          35 :         char *feat=NULL;
     116          35 :         enum protocol protocol=get_protocol(cconfs);
     117          35 :         struct strlist *startdir=get_strlist(cconfs[OPT_STARTDIR]);
     118          35 :         struct strlist *incglob=get_strlist(cconfs[OPT_INCGLOB]);
     119             : 
     120          35 :         if(append_to_feat(&feat, "extra_comms_begin ok:")
     121             :                 /* clients can autoupgrade */
     122          35 :           || append_to_feat(&feat, "autoupgrade:")
     123             :                 /* clients can give server incexc conf so that the
     124             :                    server knows better what to do on resume */
     125          35 :           || append_to_feat(&feat, "incexc:")
     126             :                 /* clients can give the server an alternative client
     127             :                    to restore from */
     128          35 :           || append_to_feat(&feat, "orig_client:")
     129             :                 /* clients can tell the server what kind of system they are. */
     130          35 :           || append_to_feat(&feat, "uname:")
     131          35 :           || append_to_feat(&feat, "failover:"))
     132             :                 goto end;
     133             : 
     134             :         /* Clients can receive restore initiated from the server. */
     135          35 :         if(set_restore_path(cconfs, &feat))
     136             :                 goto end;
     137             : 
     138             :         /* Clients can receive incexc conf from the server.
     139             :            Only give it as an option if the server has some starting
     140             :            directory configured in the clientconfdir. */
     141          35 :         if((startdir || incglob)
     142           0 :           && append_to_feat(&feat, "sincexc:"))
     143             :                 goto end;
     144             : 
     145          35 :         if(vers->cli>=vers->counters_json)
     146             :         {
     147             :                 /* Clients can be sent cntrs on resume/verify/restore. */
     148          30 :                 if(append_to_feat(&feat, "counters_json:"))
     149             :                         goto end;
     150             :         }
     151             : 
     152             :         // We support CMD_MESSAGE.
     153          35 :         if(append_to_feat(&feat, "msg:"))
     154             :                 goto end;
     155             : 
     156          35 :         if(protocol==PROTO_AUTO)
     157             :         {
     158             :                 /* If the server is configured to use either protocol, let the
     159             :                    client know that it can choose. */
     160          25 :                 logp("Server is using protocol=0 (auto)\n");
     161          25 :                 if(append_to_feat(&feat, "csetproto:"))
     162             :                         goto end;
     163             :         }
     164             :         else
     165             :         {
     166          10 :                 char p[32]="";
     167             :                 /* Tell the client what we are going to use. */
     168          10 :                 logp("Server is using protocol=%d\n", (int)protocol);
     169          10 :                 snprintf(p, sizeof(p), "forceproto=%d:", (int)protocol);
     170          10 :                 if(append_to_feat(&feat, p))
     171             :                         goto end;
     172             :         }
     173             : 
     174             : #ifdef HAVE_BLAKE2
     175             :         if(append_to_feat(&feat, "rshash=blake2:"))
     176             :                 goto end;
     177             : #endif
     178             : 
     179          35 :         if(append_to_feat(&feat, "seed:"))
     180             :                 goto end;
     181             : 
     182             :         //printf("feat: %s\n", feat);
     183             : 
     184          35 :         if(asfd->write_str(asfd, CMD_GEN, feat))
     185             :         {
     186           1 :                 logp("problem in extra_comms\n");
     187             :                 goto end;
     188             :         }
     189             : 
     190             :         ret=0;
     191             : end:
     192          35 :         free_w(&feat);
     193          35 :         return ret;
     194             : }
     195             : 
     196           2 : static int do_autoupgrade(struct asfd *asfd, struct vers *vers,
     197             :         struct conf **globalcs)
     198             : {
     199           2 :         int ret=-1;
     200           2 :         char *os=NULL;
     201           2 :         struct iobuf *rbuf=asfd->rbuf;
     202           2 :         const char *autoupgrade_dir=get_string(globalcs[OPT_AUTOUPGRADE_DIR]);
     203             : 
     204           2 :         if(!(os=strdup_w(rbuf->buf+strlen("autoupgrade:"), __func__)))
     205             :                 goto end;
     206           2 :         iobuf_free_content(rbuf);
     207           2 :         ret=0;
     208           2 :         if(os && *os)
     209             :         {
     210             :                 // Sanitise path separators
     211           7 :                 for(char *i=os; *i; ++i)
     212           7 :                         if(*i == '/' || *i == '\\' || *i == ':')
     213           0 :                                 *i='-';
     214             : 
     215           1 :                 ret=autoupgrade_server(asfd, vers->ser,
     216             :                         vers->cli, os, get_cntr(globalcs),
     217             :                         autoupgrade_dir);
     218             :         }
     219             : end:
     220           2 :         free_w(&os);
     221           2 :         return ret;
     222             : }
     223             : 
     224           0 : static int setup_seed(
     225             :         struct asfd *asfd,
     226             :         struct conf **cconfs,
     227             :         struct iobuf *rbuf,
     228             :         const char *what,
     229             :         enum conf_opt opt
     230             : ) {
     231           0 :         int ret=-1;
     232           0 :         char *tmp=NULL;
     233           0 :         char *str=NULL;
     234             : 
     235           0 :         str=rbuf->buf+strlen(what)+1;
     236           0 :         strip_trailing_slashes(&str);
     237             : 
     238           0 :         if(!is_absolute(str))
     239             :         {
     240             :                 char msg[128];
     241           0 :                 snprintf(msg, sizeof(msg), "A %s needs to be absolute!", what);
     242           0 :                 log_and_send(asfd, msg);
     243             :                 goto end;
     244             :         }
     245           0 :         if(opt==OPT_SEED_SRC && *str!='/')
     246             :         {
     247           0 : printf("here: %s\n", str);
     248             :                 // More windows hacks - add a slash to the beginning of things
     249             :                 // like 'C:'.
     250           0 :                 if(astrcat(&tmp, "/", __func__)
     251           0 :                   || astrcat(&tmp, str, __func__))
     252             :                         goto end;
     253           0 :                 str=tmp;
     254             :         }
     255           0 :         if(set_string(cconfs[opt], str))
     256             :                 goto end;
     257           0 :         ret=0;
     258             : end:
     259           0 :         free_w(&tmp);
     260           0 :         return ret;
     261             : }
     262             : 
     263          34 : static int extra_comms_read(struct async *as,
     264             :         struct vers *vers, int *srestore,
     265             :         char **incexc, struct conf **globalcs, struct conf **cconfs)
     266             : {
     267          34 :         int ret=-1;
     268             :         struct asfd *asfd;
     269             :         struct iobuf *rbuf;
     270          34 :         asfd=as->asfd;
     271          34 :         rbuf=asfd->rbuf;
     272             : 
     273             :         while(1)
     274             :         {
     275          54 :                 iobuf_free_content(rbuf);
     276          54 :                 if(asfd->read(asfd)) goto end;
     277             : 
     278          54 :                 if(rbuf->cmd!=CMD_GEN)
     279             :                 {
     280           1 :                         iobuf_log_unexpected(rbuf, __func__);
     281             :                         goto end;
     282             :                 }
     283             : 
     284          53 :                 if(!strcmp(rbuf->buf, "extra_comms_end"))
     285             :                 {
     286          24 :                         if(asfd->write_str(asfd, CMD_GEN, "extra_comms_end ok"))
     287             :                                 goto end;
     288             :                         break;
     289             :                 }
     290          29 :                 else if(!strncmp_w(rbuf->buf, "autoupgrade:"))
     291             :                 {
     292           2 :                         if(do_autoupgrade(asfd, vers, globalcs))
     293             :                                 goto end;
     294             :                 }
     295          27 :                 else if(!strcmp(rbuf->buf, "srestore ok"))
     296             :                 {
     297           4 :                         char *restore_path=get_string(cconfs[OPT_RESTORE_PATH]);
     298           4 :                         if(!restore_path)
     299             :                         {
     300           0 :                                 logp("got srestore ok without a restore_path");
     301             :                                 goto end;
     302             :                         }
     303             :                         
     304           4 :                         iobuf_free_content(rbuf);
     305             :                         // Client can accept the restore.
     306             :                         // Load the restore config, then send it.
     307           4 :                         *srestore=1;
     308             :                         // Need to wipe out OPT_INCEXDIR, as it is needed for
     309             :                         // srestore includes. If it is not wiped out, it can
     310             :                         // interfere if cconfs[OPT_RESTORE_PATH] contained no
     311             :                         // includes.
     312           4 :                         set_strlist(cconfs[OPT_INCEXCDIR], NULL);
     313           4 :                         if(conf_parse_incexcs_path(cconfs, restore_path)
     314           4 :                           || incexc_send_server_restore(asfd, cconfs))
     315             :                                 goto end;
     316             :                         // Do not unlink it here - wait until
     317             :                         // the client says that it wants to do the
     318             :                         // restore.
     319             :                         // Also need to leave it around if the
     320             :                         // restore is to an alternative client, so
     321             :                         // that the code below that reloads the config
     322             :                         // can read it again.
     323             :                         // NOTE: that appears to be in
     324             :                         // src/server/run_action.c::client_can_restore()
     325             :                         //unlink(get_string(cconfs[OPT_RESTORE_PATH]));
     326             :                 }
     327          23 :                 else if(!strcmp(rbuf->buf, "srestore not ok"))
     328             :                 {
     329           1 :                         const char *restore_path=get_string(
     330             :                                 cconfs[OPT_RESTORE_PATH]);
     331             :                         // Client will not accept the restore.
     332           1 :                         if (restore_path)
     333           1 :                                 unlink(restore_path);
     334           1 :                         if(set_string(cconfs[OPT_RESTORE_PATH], NULL))
     335             :                                 goto end;
     336           1 :                         logp("Client not accepting server initiated restore.\n");
     337             :                 }
     338          22 :                 else if(!strcmp(rbuf->buf, "sincexc ok"))
     339             :                 {
     340             :                         // Client can accept incexc conf from the
     341             :                         // server.
     342           1 :                         iobuf_free_content(rbuf);
     343           1 :                         if(incexc_send_server(asfd, cconfs))
     344             :                                 goto end;
     345             :                 }
     346          21 :                 else if(!strcmp(rbuf->buf, "incexc"))
     347             :                 {
     348             :                         // Client is telling server its incexc
     349             :                         // configuration so that it can better decide
     350             :                         // what to do on resume.
     351           1 :                         iobuf_free_content(rbuf);
     352           1 :                         if(incexc_recv_server(asfd, incexc, globalcs))
     353             :                                 goto end;
     354           1 :                         if(*incexc)
     355             :                         {
     356           1 :                                 char *tmp=NULL;
     357           1 :                                 char comp[32]="";
     358           1 :                                 snprintf(comp, sizeof(comp),
     359             :                                         "compression = %d\n",
     360             :                                         get_int(cconfs[OPT_COMPRESSION]));
     361           1 :                                 if(!(tmp=prepend(*incexc, comp)))
     362             :                                         goto end;
     363           1 :                                 free_w(incexc);
     364           1 :                                 *incexc=tmp;
     365             :                         }
     366             :                 }
     367          20 :                 else if(!strcmp(rbuf->buf, "counters_json ok"))
     368             :                 {
     369             :                         // Client can accept counters on
     370             :                         // resume/verify/restore.
     371           1 :                         logp("Client supports being sent json counters.\n");
     372           1 :                         set_int(cconfs[OPT_SEND_CLIENT_CNTR], 1);
     373             :                 }
     374          19 :                 else if(!strncmp_w(rbuf->buf, "uname=")
     375           2 :                   && strlen(rbuf->buf)>strlen("uname="))
     376             :                 {
     377           2 :                         char *uname=rbuf->buf+strlen("uname=");
     378           2 :                         if(!strncasecmp("Windows", uname, strlen("Windows")))
     379           1 :                                 set_int(cconfs[OPT_CLIENT_IS_WINDOWS], 1);
     380             :                 }
     381          17 :                 else if(!strncmp_w(rbuf->buf, "orig_client=")
     382           3 :                   && strlen(rbuf->buf)>strlen("orig_client="))
     383             :                 {
     384           3 :                         if(conf_switch_to_orig_client(globalcs, cconfs,
     385           3 :                                 rbuf->buf+strlen("orig_client=")))
     386             :                                         goto end;
     387             :                         // If this started out as a server-initiated
     388             :                         // restore, need to load the restore file
     389             :                         // again.
     390           2 :                         if(*srestore)
     391             :                         {
     392           1 :                                 if(conf_parse_incexcs_path(cconfs,
     393           1 :                                         get_string(cconfs[OPT_RESTORE_PATH])))
     394             :                                                 goto end;
     395             :                         }
     396           2 :                         if(asfd->write_str(asfd, CMD_GEN, "orig_client ok"))
     397             :                                 goto end;
     398             :                 }
     399          14 :                 else if(!strncmp_w(rbuf->buf, "restore_spool="))
     400             :                 {
     401             :                         // Removed.
     402             :                 }
     403          14 :                 else if(!strncmp_w(rbuf->buf, "protocol="))
     404             :                 {
     405          11 :                         char msg[128]="";
     406             :                         // Client wants to set protocol.
     407             :                         enum protocol protocol;
     408             :                         enum protocol cprotocol;
     409          11 :                         const char *cliproto=NULL;
     410          11 :                         protocol=get_protocol(cconfs);
     411          11 :                         cliproto=rbuf->buf+strlen("protocol=");
     412          11 :                         cprotocol=atoi(cliproto);
     413             : 
     414          11 :                         if(protocol!=PROTO_AUTO)
     415             :                         {
     416           6 :                                 if(protocol==cprotocol)
     417             :                                 {
     418           2 :                                         logp("Client is forcing protocol=%d\n", (int)protocol);
     419           2 :                                         continue;
     420             :                                 }
     421           4 :                                 snprintf(msg, sizeof(msg), "Client is trying to use protocol=%d but server is set to protocol=%d\n", (int)cprotocol, (int)protocol);
     422           4 :                                 log_and_send(asfd, msg);
     423           5 :                                 goto end;
     424             :                         }
     425           5 :                         else if(cprotocol==PROTO_1)
     426             :                         {
     427           2 :                                 set_protocol(cconfs, cprotocol);
     428           2 :                                 set_protocol(globalcs, cprotocol);
     429             :                         }
     430           3 :                         else if(cprotocol==PROTO_2)
     431             :                         {
     432           2 :                                 set_protocol(cconfs, cprotocol);
     433           2 :                                 set_protocol(globalcs, cprotocol);
     434             :                         }
     435             :                         else
     436             :                         {
     437           1 :                                 snprintf(msg, sizeof(msg), "Client is trying to use protocol=%s, which is unknown\n", cliproto);
     438           1 :                                 log_and_send(asfd, msg);
     439             :                                 goto end;
     440             :                         }
     441           4 :                         logp("Client has set protocol=%d\n",
     442           4 :                                 (int)get_protocol(cconfs));
     443             :                 }
     444           3 :                 else if(!strncmp_w(rbuf->buf, "rshash=blake2"))
     445             :                 {
     446             : #ifdef HAVE_BLAKE2
     447             :                         set_e_rshash(cconfs[OPT_RSHASH], RSHASH_BLAKE2);
     448             :                         set_e_rshash(globalcs[OPT_RSHASH], RSHASH_BLAKE2);
     449             : #else
     450           1 :                         logp("Client is trying to use librsync hash blake2, but server does not support it.\n");
     451             :                         goto end;
     452             : #endif
     453             :                 }
     454           2 :                 else if(!strncmp_w(rbuf->buf, "msg"))
     455             :                 {
     456           1 :                         set_int(cconfs[OPT_MESSAGE], 1);
     457           1 :                         set_int(globalcs[OPT_MESSAGE], 1);
     458             :                 }
     459           1 :                 else if(!strncmp_w(rbuf->buf, "backup_failovers_left="))
     460             :                 {
     461             :                         int l;
     462           0 :                         l=atoi(rbuf->buf+strlen("backup_failovers_left="));
     463           0 :                         set_int(cconfs[OPT_BACKUP_FAILOVERS_LEFT], l);
     464           0 :                         set_int(globalcs[OPT_BACKUP_FAILOVERS_LEFT], l);
     465             :                 }
     466           1 :                 else if(!strncmp_w(rbuf->buf, "seed_src="))
     467             :                 {
     468           0 :                         if(setup_seed(asfd, cconfs,
     469             :                                 rbuf, "seed_src", OPT_SEED_SRC))
     470             :                                         goto end;
     471             :                 }
     472           1 :                 else if(!strncmp_w(rbuf->buf, "seed_dst="))
     473             :                 {
     474           0 :                         if(setup_seed(asfd, cconfs,
     475             :                                 rbuf, "seed_dst", OPT_SEED_DST))
     476             :                                         goto end;
     477             :                 }
     478             :                 else
     479             :                 {
     480           1 :                         iobuf_log_unexpected(rbuf, __func__);
     481             :                         goto end;
     482             :                 }
     483             :         }
     484             : 
     485          24 :         ret=0;
     486             : end:
     487          34 :         iobuf_free_content(rbuf);
     488          34 :         return ret;
     489             : }
     490             : 
     491          39 : static int vers_init(struct vers *vers, struct conf **cconfs)
     492             : {
     493          39 :         memset(vers, 0, sizeof(struct vers));
     494          39 :         return ((vers->min=version_to_long("1.2.7"))<0
     495          39 :           || (vers->cli=version_to_long(get_string(cconfs[OPT_PEER_VERSION])))<0
     496          39 :           || (vers->ser=version_to_long(PACKAGE_VERSION))<0
     497          39 :           || (vers->feat_list=version_to_long("1.3.0"))<0
     498          39 :           || (vers->directory_tree=version_to_long("1.3.6"))<0
     499          39 :           || (vers->burp2=version_to_long("2.0.0"))<0
     500          78 :           || (vers->counters_json=version_to_long("2.0.46"))<0);
     501             : }
     502             : 
     503          22 : static int check_seed(struct asfd *asfd, struct conf **cconfs)
     504             : {
     505          22 :         char msg[128]="";
     506          22 :         const char *src=get_string(cconfs[OPT_SEED_SRC]);
     507          22 :         const char *dst=get_string(cconfs[OPT_SEED_DST]);
     508          22 :         if(!src && !dst)
     509             :                 return 0;
     510           0 :         if(src && dst)
     511             :         {
     512           0 :                 logp("Seeding '%s' -> '%s'\n", src, dst);
     513           0 :                 return 0;
     514             :         }
     515           0 :         snprintf(msg, sizeof(msg),
     516             :                 "You must specify %s and %s options together, or not at all.",
     517           0 :                         cconfs[OPT_SEED_SRC]->field,
     518           0 :                         cconfs[OPT_SEED_DST]->field);
     519           0 :         log_and_send(asfd, msg);
     520           0 :         return -1;
     521             : }
     522             : 
     523          39 : int extra_comms(struct async *as,
     524             :         char **incexc, int *srestore, struct conf **confs, struct conf **cconfs)
     525             : {
     526             :         struct vers vers;
     527             :         struct asfd *asfd;
     528          39 :         asfd=as->asfd;
     529             :         //char *restorepath=NULL;
     530          39 :         const char *peer_version=NULL;
     531             : 
     532          39 :         if(vers_init(&vers, cconfs))
     533             :                 goto error;
     534             : 
     535          39 :         if(vers.cli<vers.directory_tree)
     536             :         {
     537           3 :                 set_int(confs[OPT_DIRECTORY_TREE], 0);
     538           3 :                 set_int(cconfs[OPT_DIRECTORY_TREE], 0);
     539             :         }
     540             : 
     541             :         // Clients before 1.2.7 did not know how to do extra comms, so skip
     542             :         // this section for them.
     543          39 :         if(vers.cli<vers.min)
     544             :                 return 0;
     545             : 
     546          37 :         if(asfd_read_expect(asfd, CMD_GEN, "extra_comms_begin"))
     547             :         {
     548           1 :                 logp("problem reading in extra_comms\n");
     549           1 :                 goto error;
     550             :         }
     551             :         // Want to tell the clients the extra comms features that are
     552             :         // supported, so that new clients are more likely to work with old
     553             :         // servers.
     554          36 :         if(vers.cli==vers.feat_list)
     555             :         {
     556             :                 // 1.3.0 did not support the feature list.
     557           1 :                 if(asfd->write_str(asfd, CMD_GEN, "extra_comms_begin ok"))
     558             :                 {
     559           1 :                         logp("problem writing in extra_comms\n");
     560           1 :                         goto error;
     561             :                 }
     562             :         }
     563             :         else
     564             :         {
     565          35 :                 if(send_features(asfd, cconfs, &vers))
     566             :                         goto error;
     567             :         }
     568             : 
     569          34 :         if(extra_comms_read(as, &vers, srestore, incexc, confs, cconfs))
     570             :                 goto error;
     571             : 
     572          24 :         peer_version=get_string(cconfs[OPT_PEER_VERSION]);
     573             : 
     574             :         // This needs to come after extra_comms_read, as the client might
     575             :         // have set PROTO_1 or PROTO_2.
     576          24 :         switch(get_protocol(cconfs))
     577             :         {
     578             :                 case PROTO_AUTO:
     579             :                         // The protocol has not been specified. Make a choice.
     580          14 :                         if(vers.cli<vers.burp2)
     581             :                         {
     582             :                                 // Client is burp-1.x.x, use protocol1.
     583           1 :                                 set_protocol(confs, PROTO_1);
     584           1 :                                 set_protocol(cconfs, PROTO_1);
     585           1 :                                 logp("Client is %s-%s - using protocol=%d\n",
     586             :                                         PACKAGE_TARNAME,
     587             :                                         peer_version, PROTO_1);
     588             :                         }
     589             :                         else
     590             :                         {
     591             :                                 // Client is burp-2.x.x, use protocol2.
     592             :                                 // This will probably never be reached because
     593             :                                 // the negotiation will take care of it.
     594             :                                 /*
     595             :                                 set_protocol(confs, PROTO_2);
     596             :                                 set_protocol(cconfs, PROTO_2);
     597             :                                 logp("Client is %s-%s - using protocol=%d\n",
     598             :                                         PACKAGE_TARNAME,
     599             :                                         peer_version, PROTO_2);
     600             :                                 */
     601             :                                 // PROTO_1 is safer for now.
     602          13 :                                 set_protocol(confs, PROTO_1);
     603          13 :                                 set_protocol(cconfs, PROTO_1);
     604          13 :                                 logp("Client is %s-%s - using protocol=%d\n",
     605             :                                         PACKAGE_TARNAME,
     606             :                                         peer_version, PROTO_1);
     607             :                         }
     608             :                         break;
     609             :                 case PROTO_1:
     610             :                         // It is OK for the client to be burp1 and for the
     611             :                         // server to be forced to protocol1.
     612             :                         break;
     613             :                 case PROTO_2:
     614           5 :                         if(vers.cli>=vers.burp2)
     615             :                                 break;
     616           2 :                         logp("protocol=%d is set server side, "
     617             :                           "but client is %s version %s\n",
     618             :                           PROTO_2, PACKAGE_TARNAME, peer_version);
     619           2 :                         goto error;
     620             :         }
     621             : 
     622          22 :         if(get_protocol(cconfs)==PROTO_1)
     623             :         {
     624          19 :                 if(get_e_rshash(cconfs[OPT_RSHASH])==RSHASH_UNSET)
     625             :                 {
     626          19 :                         set_e_rshash(confs[OPT_RSHASH], RSHASH_MD4);
     627          19 :                         set_e_rshash(cconfs[OPT_RSHASH], RSHASH_MD4);
     628             :                 }
     629             :         }
     630             : 
     631          22 :         if(check_seed(asfd, cconfs))
     632             :                 goto error;
     633             : 
     634             :         return 0;
     635             : error:
     636             :         return -1;
     637             : }

Generated by: LCOV version 1.13