source: TI05-delivery/trunk/src/bbftp-client-3.2.0/bbftpc/bbftp.c @ 773

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI05-delivery/trunk/src/bbftp-client-3.2.0/bbftpc/bbftp.c@773
Revision 773, 49.2 KB checked in by spascoe, 15 years ago (diff)

Initial import of bbftp source

Line 
1/*
2 * bbftpc/bbftp.c
3 * Copyright (C) 1999, 2000, 2001, 2002 IN2P3, CNRS
4 * bbftp@in2p3.fr
5 * http://doc.in2p3.fr/bbftp
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20 */ 
21
22/****************************************************************************
23
24
25 
26 
27 bbftp.c  v 2.0.0  2001/03/01   - Complete rewriting for version 2.0.0
28          v 2.0.1  2001/04/19   - Correct indentation
29                                - Verify if -s is present on shhremotecmd
30                                  and add it if not (in order to fit v 1.9.4-tja1
31                                  behaviour)
32          v 2.1.0 2001/05/21    - Add debug
33                                - Add -m option to have special output
34                                - Set -v before all options
35                                - Correct case where the last line in control
36                                  file has no CR
37          v 2.1.2 2001/11/19    - Fix COS 0 case
38          v 2.2.0 2001/10/03    - Add certificate authentication mode
39
40*****************************************************************************/
41#include <bbftp.h>
42
43#include <errno.h>
44#include <fcntl.h>
45#include <netdb.h>
46#include <netinet/in.h>
47#include <pwd.h>
48#include <stdio.h>
49#include <sys/stat.h>
50#include <sys/types.h>
51#include <unistd.h>
52#if TIME_WITH_SYS_TIME
53# include <sys/time.h>
54# include <time.h>
55#else
56# if HAVE_SYS_TIME_H
57#  include <sys/time.h>
58# else
59#  include <time.h>
60# endif
61#endif
62#if HAVE_STRING_H
63# include <string.h>
64#endif
65
66#include <client.h>
67#include <client_proto.h>
68#include <common.h>
69#include <config.h>
70#include <structures.h>
71#include <version.h>
72
73#ifdef WITH_SSL
74#include <openssl/rsa.h>
75#endif
76
77#ifdef WITH_GZIP
78# include <zlib.h>
79#endif
80
81#define SETTOZERO    0
82#define SETTOONE     1
83
84#define SSHREMOTECMD "bbftpd -s"
85#define SSHCMD "ssh -q"
86
87#ifdef PRIVATE_AUTH
88#define OPTIONS "qbcde:f:i:l:mno:p:P:r:R:tu:vVw:WD::"
89#else
90#define OPTIONS "qbcde:E:f:g:i:I:l:L:mno:p:r:R:sStu:vVw:WD::"
91#endif
92/*
93#endif
94*/
95
96int     state   = SETTOZERO ;
97/*
98** timestamp:
99**      Every message on standart error and standart output are
100**      timestamped
101*/
102int     timestamp = SETTOZERO ;
103/*
104** protocolmin:
105**      Minimum protocol supportted
106*/
107int     protocolmin = 2 ; 
108int     protocolmax = 3 ; 
109int     protocol ;
110/*
111** debug:
112**      Set to one to print more debugging information
113*/
114int     debug = SETTOZERO ;
115/*
116** verbose:
117**      Set to one to print  information
118*/
119int     verbose = SETTOZERO ;
120/*
121** warning:
122**      Set to one to print warning to stderr
123*/
124int     warning = SETTOZERO ;
125/*
126** statoutput:
127**      Set to one for special output
128*/
129int     statoutput = SETTOZERO ;
130/*
131** globaltrymax:
132**      Number of try in case or recoverable error
133*/
134int     globaltrymax = NBTRYMAX ;
135/*
136** newcontrolport:
137**      Control port to be used
138*/
139int     newcontrolport = CONTROLPORT ;
140/*
141** usessh:
142**      Set to one when using ssh to start the remote daemon
143*/
144int     usessh = SETTOZERO ;
145/*
146** sshbatchmode:
147**      This is set to non-zero if running in batch mode (that is, password
148**      and passphrase queries are not allowed).
149*/
150int     sshbatchmode  = SETTOZERO ;
151/*
152** sshchildpid:
153**      To keep the ssh child pid
154*/
155int     sshchildpid   = SETTOZERO ;
156/*
157** For ssh
158*/
159char    *sshidentityfile = NULL ;
160char    *sshremotecmd = NULL ;
161char    *sshcmd = NULL ;
162/*
163** usecert:
164**              Set to one if using certificate authentifaction
165*/
166int             usecert = SETTOZERO ;
167/*
168** useprivate:
169**      Set to one if using private authentication
170*/
171int     useprivate = SETTOZERO ;
172/*
173** privatestr:
174**      Pointer to a private string used for private authentication
175**
176*/
177char    *privatestr = NULL ;
178/*
179** hisctladdr:
180**      the remote address
181*/
182struct sockaddr_in hisctladdr ;
183/*
184** myctladdr:
185**      the local address
186*/
187struct sockaddr_in myctladdr ;
188/*
189** bbftprc:
190**      Where to store the bbftprc file
191*/
192char    *bbftprc = NULL ;
193/*
194** Variable defining the local options :
195**
196** localcos:
197**      Value of the local class of service (in case of RFIO ability)
198**
199** localumask:
200**      Local umask taken by the umask command at start and
201**      modified by the setlocalumask command
202**
203** localrfio:
204**      set to one when using rfio for local files
205**
206*/
207int     localumask ;
208#if defined(WITH_RFIO) || defined(WITH_RFIO64)
209int     localcos  = SETTOZERO ;
210#endif
211
212char *newcmd = NULL;
213int remoterfio;
214int localrfio;
215/*
216** Variables defining both side options :
217**
218** usetmpfile:
219**      Set to one when using tmpname for file creation
220**
221** usegzipcompress:
222**      Set to one when using tmpname for file creation
223**
224** keepaccess:
225**      Set to one when keeping access time and modification
226**
227** keepmode:
228**      Set to one when keeping file mode
229**
230** creatdir:
231**      Set to one when automatic directory creation is needed
232*/
233int     sendwinsize     = 256 ;
234int     recvwinsize     = 256 ;
235int     nbport = 1 ;
236int             ackto                   = ACKTO;
237int             recvcontrolto   = CONTROLSOCKTO;
238int             sendcontrolto   = SENDCONTROLTO;
239int             datato                  = DATASOCKTO;
240
241/*
242** Variables remote side options :
243**
244** remoterfio:
245**      Set to one when rfio for remote file
246**
247** remoteumask:
248**      if set to zero do not set remote umask
249**
250** remotecos:
251**      if not set to zero do set remote cos
252**
253** remotedir :
254**      if not set to NULL change dir after connection
255**
256*/
257int     remoteumask = SETTOZERO ;
258int     remotecos   = -1 ;
259char    *remotedir = NULL ;
260/*
261** incontrolsock :
262**      Define the control socket for reading
263** outcontrolsock :
264**      Define the control socket for writing
265**
266**      For normal use : incontrolsock = outcontrolsock
267*/
268int     incontrolsock ;
269int     outcontrolsock ;
270/*
271** myexitcode :
272**      Contains the first error code that has to be return when program
273**      is ended
274*/
275int     myexitcode = SETTOZERO ;
276char    *hostname   = NULL ;
277struct hostent  *hp = NULL ;
278char    *username   = NULL ;
279char    *password   = NULL ;
280#ifdef CERTIFICATE_AUTH
281char    *service    = NULL ;
282#endif
283/*
284** mychildren :
285**      Pointer to the first pid of children
286*/
287int     *mychildren = NULL ;
288/*
289** nbpidchid :
290**      Number of pid pointed by mychildren
291*/
292int     nbpidchild ;
293/*
294** castfd:
295**      CASTOR file descriptor
296*/
297#ifdef CASTOR
298int     castfd = -1 ;
299char    *castfilename = NULL ;
300#endif
301
302/*
303** Parameters describing the transfer ********************
304*/
305int     transferoption = TROPT_TMP | TROPT_DIR | TROPT_MODE | TROPT_ACC; 
306int     filemode ;
307char    lastaccess[9] ;
308char    lastmodif[9] ;
309int     buffersizeperstream = 256 ;
310int     requestedstreamnumber ;
311my64_t  filesize ;
312/*
313** curfilename :
314**      Define the pointer to the current file
315*/
316char    *curfilename = NULL ;
317/*
318** realfilename :
319**      Define the pointer to the real file (= curfilename if TROPT_TMP not
320**      set)
321*/
322char    *realfilename   = NULL ;
323int     *myports        = NULL ;
324int     *mysockets      = NULL ;
325char    *readbuffer     = NULL ;
326char    *compbuffer     = NULL ; 
327int     resfd = -1 ;
328/*
329** Simulation mode (option -n)
330*/
331int             simulation_mode = SETTOZERO;
332/*
333**
334*/
335int connectionisbroken = SETTOZERO ;
336
337/*
338 * Range for the ephemeral ports for data connections
339 */
340int     pasvport_min = 0 ;
341int     pasvport_max = 0 ;
342
343typedef struct cmd_list_st {
344        char *cmd;
345        struct cmd_list_st *next;
346} cmd_list;
347cmd_list *commandList = NULL;
348cmd_list *first = NULL;
349cmd_list *iterator = NULL;
350
351int addCommand(char *newcmd) {
352    cmd_list *newCommand = NULL;
353    if ((newCommand  = (cmd_list *)malloc(sizeof(cmd_list))) == NULL) {
354           printmessage(stderr,CASE_FATAL_ERROR,23,timestamp,"Unable to malloc memory for command list : %s\n",strerror(errno)) ;
355    }
356    if ((newCommand->cmd = (char *) malloc( strlen(newcmd) + 1)) == NULL) {
357           printmessage(stderr,CASE_FATAL_ERROR,23,timestamp,"Unable to malloc memory for command : %s\n",strerror(errno)) ;
358    }
359    strcpy(newCommand->cmd, newcmd);
360    newCommand->next = NULL;
361    if (iterator == NULL) {
362            iterator = newCommand;
363            first = newCommand;
364    } else {
365            iterator->next = newCommand;
366            iterator = iterator->next;
367    }
368}
369
370main(argc, argv, envp)
371    int argc;
372    char **argv;
373    char **envp;
374{
375    extern char *optarg;
376    extern int optind, opterr, optopt;
377/*
378** Variable set by options
379*/
380    char    *inputfile  = NULL ;
381    char    *resultfile = NULL ;
382    char    *outputfile = NULL ;
383    char    *errorfile  = NULL ;
384    char    *bbftpcmd   = NULL ;
385    int     background  = SETTOZERO ;
386/*
387** For hostname
388*/ 
389    int     hosttype = 0 ;
390    char    *calchostname ;
391/*
392** For local user
393*/
394    struct  passwd  *mypasswd ;
395    char    *bbftprcfile = NULL ;
396    int     fd ;
397    char    *carret ;
398    char    *startcmd ;
399    int     nooption ;
400   
401    struct  stat    statbuf ;
402    int     retcode ;
403    int     i, j, k ;
404    int     stderrfd ;
405    int     stdoutfd ;
406    int     infd ;
407    char    calcmaxline[1] ;
408    int     maxlen ;
409    int     lengthread ;
410    char    *buffercmd ;
411    int     alluse ;
412    char    *tmpsshremotecmd ;
413    char    logmessage[1024] ;
414    char    minbuffer[MINMESSLEN] ;
415    struct  message *msg ;
416/*
417** Get local umask
418*/
419    localumask = umask(0) ;
420/*
421** and reset it to the correct value
422*/
423    umask(localumask) ;
424/*
425** First check for timestamp in order to have a common output
426*/
427    opterr = 0 ;
428    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
429        switch (j) {
430            case 't' :{
431                timestamp = SETTOONE ;
432                break ;
433            }
434        }
435    }
436
437#ifdef PRIVATE_AUTH
438    useprivate = SETTOONE ;
439    usessh = SETTOZERO ;
440#endif
441
442/*
443** Check for -v option
444*/
445    opterr = 0 ;
446    optind = 1 ;
447    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
448        switch (j) {
449            case 'v' :{
450                printmessage(stdout,CASE_NORMAL,0,timestamp,"bbftp version %s\n",VERSION) ;
451                printmessage(stdout,CASE_NORMAL,0,timestamp,"Compiled with  :   default port %d\n",CONTROLPORT) ;
452#ifdef PORT_RANGE
453                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   data ports range = %s \n", PORT_RANGE) ;
454#endif
455#ifdef WITH_GZIP
456                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   compression with Zlib-%s\n", zlibVersion()) ;
457#endif
458#ifdef WITH_SSL
459                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   encryption with %s \n",SSLeay_version(SSLEAY_VERSION)) ;
460#endif
461#ifdef WITH_RFIO
462# ifdef CASTOR
463                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   CASTOR support (RFIO)\n") ;
464# else
465                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   HPSS support (RFIO)\n") ;
466# endif
467#endif
468#ifdef WITH_RFIO64
469# ifdef CASTOR
470                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   CASTOR support (RFIO64)\n") ;
471# else
472                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   HPSS support (RFIO64)\n") ;
473# endif
474#endif
475#ifdef AFS
476                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   AFS authentication \n") ;
477#endif
478#ifdef PRIVATE_AUTH
479                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   private authentication \n") ;
480#else
481                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default ssh command = %s \n",SSHCMD) ;
482                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default ssh remote command = %s \n",SSHREMOTECMD) ;
483# ifdef CERTIFICATE_AUTH
484                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   GSI authentication\n") ;
485# endif
486#endif
487                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default number of tries = %d  \n",NBTRYMAX) ;
488                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default sendwinsize = %d Kbytes\n",sendwinsize) ;
489                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default recvwinsize = %d Kbytes\n",recvwinsize) ;
490                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default number of stream = %d \n",nbport) ;
491                exit(0) ;
492            }
493        }
494    }
495
496/*
497** Check for stderr replacement
498*/
499    opterr = 0 ;
500    optind = 1 ;
501    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
502        switch (j) {
503            case 'f' :{
504                errorfile = optarg ;
505                break ;
506            }
507        }
508    }
509    if ( errorfile != NULL ) {
510#ifdef DARWIN
511                if ( (stderrfd = open(errorfile,O_CREAT|O_WRONLY|O_TRUNC,0777)) < 0 ) {
512#else
513        if ( (stderrfd = open(errorfile,O_CREAT|O_WRONLY|O_SYNC|O_TRUNC,0777)) < 0 ) {
514#endif
515                printmessage(stderr,CASE_FATAL_ERROR,10,timestamp,"Error openning error file (%s) : %s\n",errorfile,strerror(errno)) ;
516        }
517        close(STDERR_FILENO);
518        if ( fcntl(stderrfd,F_DUPFD,STDERR_FILENO) != STDERR_FILENO ) {
519            printmessage(stderr,CASE_FATAL_ERROR,11,timestamp,"Error dup on error file (%s) : %s\n",errorfile,strerror(errno)) ;
520        }
521    }
522/*
523** Check for stdout replacement
524*/
525    opterr = 0 ;
526    optind = 1 ;
527    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
528        switch (j) {
529            case 'o' :{
530                outputfile = optarg ;
531                break ;
532            }
533        }
534    }
535    if ( outputfile != NULL ) {
536#ifdef DARWIN
537                if ( (stdoutfd = open(outputfile,O_CREAT|O_WRONLY|O_TRUNC,0777)) < 0 ) {
538#else
539        if ( (stdoutfd = open(outputfile,O_CREAT|O_WRONLY|O_SYNC|O_TRUNC,0777)) < 0 ) {
540#endif
541                printmessage(stderr,CASE_FATAL_ERROR,12,timestamp,"Error openning output file (%s) : %s\n",outputfile,strerror(errno)) ;
542        }
543        close(STDOUT_FILENO);
544        if ( fcntl(stdoutfd,F_DUPFD,STDOUT_FILENO) != STDOUT_FILENO ) {
545            printmessage(stderr,CASE_FATAL_ERROR,13,timestamp,"Error dup on output file (%s) : %s\n",outputfile,strerror(errno)) ;
546        }
547    }
548
549/*
550** Block all signals , the routine will exit in case of error
551*/
552    blockallsignals() ;
553
554/*
555** Now all the others
556*/
557    opterr = 0 ;
558    optind = 1 ;
559    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
560        switch (j) {
561            case 'b' :{
562                background = SETTOONE ;
563                break ;
564            }
565            case 'c' :{
566#ifdef WITH_GZIP               
567                transferoption = transferoption | TROPT_GZIP ;
568#else
569                printmessage(stderr,CASE_FATAL_ERROR,7,timestamp,"option -c is not available: bbftp was built without compression utility\n") ;
570#endif               
571                break ;
572            }
573            case 'd' :{
574                debug = 1 ;
575                break ;
576            }
577            case 'D' :{         
578                if (optarg) {
579                    if ((sscanf(optarg,"%d:%d",&i, &k) == 2) && (i < k)) {
580                        pasvport_min = i; pasvport_max = k;
581                    } else {
582                        printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Invalid port range : %s\n",optarg) ;
583                    }
584                } else {
585#ifdef PORT_RANGE
586                     sscanf(PORT_RANGE,"%d:%d",&pasvport_min, &pasvport_max) ;
587#endif
588                     if (0 == pasvport_max) {
589                         pasvport_min = 0;
590                         pasvport_max = 1;
591                     }
592                }
593                protocolmax = 2 ;
594                break ;
595            }
596            case 'e' : {
597                bbftpcmd = optarg ;
598                break ;
599            }
600            case 'E' : {
601                sshremotecmd = optarg ;
602                usessh = 1 ;
603                break ;
604            }
605            case 'f' :{
606                errorfile = optarg ;
607                break ;
608            }
609#ifdef CERTIFICATE_AUTH
610            case 'g' :{
611                service = optarg ;
612                break ;
613            }
614#endif         
615            case 'i' :{
616                inputfile = optarg ;
617                if ( stat (inputfile,&statbuf) < 0 ) {
618                    printmessage(stderr,CASE_FATAL_ERROR,7,timestamp,"Input file (%s) cannot be stated\n",inputfile) ;
619                }
620                if ( (resultfile = (char *) malloc (strlen(inputfile) + 5 )) == NULL ) {
621                    printmessage(stderr,CASE_FATAL_ERROR,1,timestamp,"Cannot malloc space for result file name\n") ;
622                }
623                strcpy(resultfile,inputfile) ;
624                strcat(resultfile,".res") ;
625                break ;
626            }
627            case 'I' :{
628                sshidentityfile = optarg ;
629                usessh = 1 ;
630                /*
631                ** Check if file exists
632                */
633                if ( stat (sshidentityfile,&statbuf) < 0 ) {
634                    printmessage(stderr,CASE_FATAL_ERROR,5,timestamp,"SSH identity file (%s) cannot be stated\n",sshidentityfile) ;
635                }
636                break ;
637            }
638            case 'L' : {
639                sshcmd = optarg ;
640                usessh = 1 ;
641                break ;
642            }
643            case 'm' :{
644                statoutput = SETTOONE ;
645                break ;
646            }
647            case 'n':{
648                simulation_mode = SETTOONE ;
649                break ;
650            }
651            case 'o' :{
652                outputfile = optarg ;
653                break ;
654            }
655            case 'P' :{
656                privatestr = optarg ;
657                break ;
658            }
659            case 'q' :{
660                transferoption = transferoption | TROPT_QBSS ;
661                                break ;
662                        }
663            case 'p' :{
664                retcode = sscanf(optarg,"%d",&alluse) ;
665                if ( retcode != 1 || alluse < 0) {
666                    printmessage(stderr,CASE_FATAL_ERROR,3,timestamp,"Number of streams must be numeric and > 0\n") ;
667                }
668                nbport = alluse ;
669                break ;
670            }
671            case 'r' :{
672                retcode = sscanf(optarg,"%d",&alluse) ;
673                if ( retcode != 1 || alluse <= 0) {
674                    printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Number of tries must be numeric > 0\n") ;
675                }
676                globaltrymax = alluse ;
677                break ;
678            }
679            case 'R' :{
680                bbftprcfile = optarg ;
681                break ;
682            }
683            case 's' :{
684                usessh = SETTOONE ;
685                break ;
686            }
687            case 'S' :{
688                usessh = SETTOONE ;
689                sshbatchmode = SETTOONE ;
690                break ;
691            }
692            case 't' :{
693                timestamp = SETTOONE ;
694                break ;
695            }
696            case 'u' :{
697                username = optarg ;
698                break ;
699            }
700            case 'V':{
701                verbose = SETTOONE ;
702                break ;
703            }
704            case 'w' :{
705                retcode = sscanf(optarg,"%d",&alluse) ;
706                if ( retcode != 1 || alluse <= 0) {
707                    printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Control port must be numeric\n") ;
708                }
709                newcontrolport = alluse ;
710                break ;
711            }
712            case 'W':{
713                warning = SETTOONE ;
714                break ;
715            }
716            default : {
717                Usage() ;
718                printmessage(stderr,CASE_FATAL_ERROR,6,timestamp,"Error on command line (unsupported option -%c)\n",optopt) ;
719            }
720        }
721    }
722    /*
723    ** Get 5K for castfilename in order to work with CASTOR
724    ** software (even if we are not using it)
725    */
726#ifdef CASTOR
727    if ( (castfilename = (char *) malloc (5000)) == NULL ) {
728        /*
729        ** Starting badly if we are unable to malloc 5K
730        */
731        printmessage(stderr,CASE_FATAL_ERROR,10,timestamp,"No memory for CASTOR : %s\n",strerror(errno)) ;
732    }
733#endif
734
735    /*
736    ** Reset all outputs variable if statoutput is set to one
737    */
738    if ( statoutput ) {
739        debug     = SETTOZERO ;
740        verbose   = SETTOZERO ;
741        warning   = SETTOZERO ;
742        timestamp = SETTOZERO ;
743    }
744/*
745#ifdef PRIVATE_AUTH
746    useprivate = SETTOONE ;
747    usessh = SETTOZERO ;
748#endif
749
750#ifdef CERTIFICATE_AUTH
751        usecert = SETTOONE ;
752    useprivate = SETTOZERO ;
753    usessh = SETTOZERO ;
754#endif
755*/             
756 
757/*
758** Check all ssh stuff
759*/
760    if ( usessh) {
761        if ( sshremotecmd == NULL ) {
762            /*
763            ** Malloc space and set the default
764            */
765            if ( (sshremotecmd = (char *) malloc (strlen(SSHREMOTECMD)+1) ) == NULL ) {
766                printmessage(stderr,CASE_FATAL_ERROR,8,timestamp,"Cannot malloc space for ssh remote cmd\n") ;
767            }
768            strcpy(sshremotecmd,SSHREMOTECMD) ;
769        } else {
770            /*
771            ** Verify if -s is present if not add it (in order to fit v 1.9.4-tja1
772            ** behaviour)
773            */
774            if ( strstr(sshremotecmd," -s") == NULL ) {
775                if ( ( tmpsshremotecmd = (char *) malloc (strlen(sshremotecmd) + 4) ) == NULL ) {
776                    printmessage(stderr,CASE_FATAL_ERROR,8,timestamp,"Cannot malloc space for ssh remote cmd\n") ;
777                }
778                sprintf(tmpsshremotecmd,"%s -s",sshremotecmd) ;
779                sshremotecmd = tmpsshremotecmd ;
780            }
781        }
782        if ( sshcmd == NULL ) {
783            if ( (sshcmd = (char *) malloc (strlen(SSHCMD)+1) ) == NULL ) {
784                  printmessage(stderr,CASE_FATAL_ERROR,9,timestamp,"Cannot malloc space for ssh cmd\n") ;
785            }
786            strcpy(sshcmd,SSHCMD) ;
787        }
788    }
789/*
790** Check for the local user in order to find the .bbftprc file
791*/
792    if ( bbftprcfile == NULL ) {
793        /*
794        ** look for the local user in order to find the .bbftprc file
795        */
796        if ( (mypasswd = getpwuid(getuid())) == NULL ) {
797            if ( warning ) printmessage(stderr,CASE_WARNING,6,timestamp,"Unable to get passwd entry, using %s\n", BBFTP_CONF) ;
798            if ( (bbftprcfile = (char *) malloc (strlen(BBFTP_CONF)+1) ) != NULL ) {
799              strcpy(bbftprcfile,BBFTP_CONF);
800            }
801        } else if ( mypasswd->pw_dir == NULL ) {
802            if ( warning ) printmessage(stderr,CASE_WARNING,7,timestamp,"No home directory, using %s\n", BBFTP_CONF) ;
803            if ( (bbftprcfile = (char *) malloc (strlen(BBFTP_CONF)+1) ) != NULL ) {
804              strcpy(bbftprcfile,BBFTP_CONF);
805            }
806        } else if ( (bbftprcfile = (char *) malloc (strlen(mypasswd->pw_dir)+10) ) == NULL ) {
807            if ( warning ) printmessage(stderr,CASE_WARNING,8,timestamp,"Error allocationg space for bbftprc file name, .bbftprc will not be used\n") ;
808        } else {
809            strcpy(bbftprcfile,mypasswd->pw_dir) ;
810            strcat(bbftprcfile,"/.bbftprc") ;
811            if ( stat(bbftprcfile,&statbuf) < 0  ) {
812                bbftprcfile == NULL;
813                if ( (bbftprcfile = (char *) malloc (strlen(BBFTP_CONF)+1) ) != NULL ) {
814                  strcpy(bbftprcfile,BBFTP_CONF);
815                }
816            }
817        }
818    }
819    if ( bbftprcfile != NULL ) {
820        if ( strncmp(bbftprcfile,"none",4) != 0 ) {
821            /*
822            ** Stat the file in order to get the length
823            */
824            if ( stat(bbftprcfile,&statbuf) < 0  ) {
825                if ( warning ) printmessage(stderr,CASE_WARNING,9,timestamp,"Error stating bbftprc file (%s)\n",bbftprcfile) ;
826            } else if ( statbuf.st_size == 0 ) {
827                /*
828                ** do nothing
829                */
830            } else if ( (bbftprc = (char *) malloc (statbuf.st_size + 1 ) ) == NULL ) {
831                if ( warning ) printmessage(stderr,CASE_WARNING,10,timestamp,"Error allocation memory for bbftprc, .bbftprc will not be used\n") ;
832            } else if ( ( fd  = open (bbftprcfile,O_RDONLY) )  < 0 ) {
833                if ( warning ) printmessage(stderr,CASE_WARNING,11,timestamp,"Error openning .bbftprc file (%s) : %s \n",bbftprcfile,strerror(errno)) ;
834            } else if ( ( j = read( fd, bbftprc , statbuf.st_size )) != statbuf.st_size ) {
835                if ( warning ) printmessage(stderr,CASE_WARNING,12,timestamp,"Error reading .bbftprc file (%s)\n",bbftprcfile) ;
836            } else {
837                bbftprc[j] = '\0' ;
838            }
839        }
840    }
841/*
842** Analyse the bbftprc command in order to supress forbiden command
843** Allowed commands are :
844**          setbuffersize %d
845**          setlocalcos %d
846**          setremotecos %d
847**          setlocalumask %ooo
848**          setremoteumask %ooo
849**          setsendwinsize %d
850**          setrecvwinsize %d
851**          setnbstream %d
852**          setoption [ [no]createdir | [no]tmpfile | [no]remoterfio | [no]localrfio | [no]keepmode |[no]keepaccess |[no]gzip]
853**
854*/
855    if ( bbftprc != NULL ) {
856        carret = bbftprc ;
857        startcmd = bbftprc ;
858        /*
859        ** Strip starting CR
860        */
861        while (1) {
862            while ( *carret == 10 || *carret == ' ' ) carret++ ;
863            startcmd = carret ;
864            carret = (char *) strchr (carret, 10);
865            if ( carret == NULL ) break ;
866            *carret = '\0' ;
867            if ( !strncmp(startcmd,"setbuffersize",13)) {
868                retcode = sscanf(startcmd,"setbuffersize %d",&alluse) ;
869                if ( retcode != 1 || alluse < 0 ) {
870                    if ( warning ) printmessage(stderr,CASE_WARNING,5,timestamp,"Buffersize in bbftprc file must be numeric > 0\n") ;
871                } else {
872                    buffersizeperstream = alluse ;
873                }
874#if defined(WITH_RFIO) || defined(WITH_RFIO64)
875            } else if ( !strncmp(startcmd,"setlocalcos",11)) {
876                retcode = sscanf(startcmd,"setlocalcos %d",&alluse) ;
877                if ( retcode != 1 /*|| alluse < 0*/) {
878                    if ( warning ) printmessage(stderr,CASE_WARNING,14,timestamp,"Local COS in bbftprc file must be numeric\n") ;
879                } else {
880                    localcos = alluse ;
881                }
882#endif
883            } else if (!strncmp(startcmd,"setremotecos",12)) {
884                retcode = sscanf(startcmd,"setremotecos %d",&alluse) ;
885                if ( retcode != 1 /*|| alluse < 0*/) {
886                    if ( warning ) printmessage(stderr,CASE_WARNING,15,timestamp,"Remote COS in bbftprc file must be numeric\n") ;
887                }else {
888                    remotecos = alluse ;
889                }
890            } else if (!strncmp(startcmd,"setlocalumask",13)) {
891                retcode = sscanf(startcmd,"setlocalumask %o",&alluse) ;
892                if ( retcode != 1 || alluse < 0) {
893                    if ( warning ) printmessage(stderr,CASE_WARNING,16,timestamp,"Local umask in bbftprc file must be numeric\n") ;
894                } else {
895                    localumask = alluse ;
896                    umask(localumask) ;
897                }
898            } else if (!strncmp(startcmd,"setremoteumask",14)) {
899                retcode = sscanf(startcmd,"setremoteumask %o",&alluse) ;
900                if ( retcode != 1  || alluse < 0) {
901                    if ( warning ) printmessage(stderr,CASE_WARNING,17,timestamp,"Remote umask in bbftprc file must be numeric\n") ;
902                }else {
903                    remoteumask = alluse ;
904                    umask(localumask) ;
905                }
906            } else if (!strncmp(startcmd,"setsendwinsize",14)) {
907                retcode = sscanf(startcmd,"setsendwinsize %d",&alluse) ;
908                if ( retcode != 1 || alluse < 0 ) {
909                    if ( warning ) printmessage(stderr,CASE_WARNING,18,timestamp,"Send window size in bbftprc file must be numeric\n") ;
910                } else {
911                    sendwinsize = alluse ;
912                }
913            } else if (!strncmp(startcmd,"setrecvwinsize",14)) {
914                retcode = sscanf(startcmd,"setrecvwinsize %d",&alluse) ;
915                if ( retcode != 1 || alluse < 0  ) {
916                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Receive window size in bbftprc file must be numeric\n") ;
917                }else {
918                    recvwinsize = alluse ;
919                }
920            } else if (!strncmp(startcmd,"setnbstream",11)) {
921                retcode = sscanf(startcmd,"setnbstream %d",&alluse) ;
922                if ( retcode != 1  || alluse <= 0 ) {
923                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Number of streams in bbftprc file must be numeric and > 0\n") ;
924                } else {
925                    nbport = alluse ;
926                }
927            } else if (!strncmp(startcmd,"setackto",8)) {
928                retcode = sscanf(startcmd,"setackto %d",&alluse) ;
929                if ( retcode != 1  || alluse <= 0 ) {
930                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Acknowledge timeout must be numeric and > 0\n") ;
931                } else {
932                    ackto = alluse ;
933                }
934            } else if (!strncmp(startcmd,"setrecvcontrolto",16)) {
935                retcode = sscanf(startcmd,"setrecvcontrolto %d",&alluse) ;
936                if ( retcode != 1  || alluse <= 0 ) {
937                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Input control timeout must be numeric and > 0\n") ;
938                } else {
939                    recvcontrolto = alluse ;
940                }
941            } else if (!strncmp(startcmd,"setsendcontrolto",16)) {
942                retcode = sscanf(startcmd,"setsendcontrolto %d",&alluse) ;
943                if ( retcode != 1  || alluse <= 0 ) {
944                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Output control timeout must be numeric and > 0\n") ;
945                } else {
946                    sendcontrolto = alluse ;
947                }
948            } else if (!strncmp(startcmd,"setdatato",9)) {
949                retcode = sscanf(startcmd,"setdatato %d",&alluse) ;
950                if ( retcode != 1  || alluse <= 0 ) {
951                    if ( warning ) printmessage(stderr,CASE_WARNING,19,timestamp,"Data timeout must be numeric and > 0\n") ;
952                } else {
953                    datato = alluse ;
954                }
955            } else if (!strncmp(startcmd,"setoption",9)) {
956                /*
957                ** look for the option
958                */
959                startcmd = startcmd + 9 ;
960                while (*startcmd == ' ' && *startcmd != '\0' ) startcmd++ ;
961                if ( !strncmp(startcmd,"no",2) ) {
962                    nooption = SETTOONE ;
963                    startcmd = startcmd+2 ;
964                } else {
965                    nooption = SETTOZERO ;
966                }
967                if ( !strncmp(startcmd,"createdir",9) ) {
968                    if ( nooption ) {
969                        transferoption = transferoption & ~TROPT_DIR ;
970                    } else {
971                        transferoption = transferoption | TROPT_DIR ;
972                   }
973                } else if ( !strncmp(startcmd,"tmpfile",7) ) {
974                    if ( nooption ) {
975                        transferoption = transferoption & ~TROPT_TMP ;
976                    } else {
977                        transferoption = transferoption | TROPT_TMP ;
978                   }
979                } else if ( !strncmp(startcmd,"remoterfio",10) ) {
980                    if ( nooption ) {
981                        transferoption = transferoption & ~TROPT_RFIO ;
982                    } else {
983                        transferoption = transferoption | TROPT_RFIO ;
984                        if ( remotecos == -1 ) remotecos = 0;
985                    }
986                } else if ( !strncmp(startcmd,"localrfio",9) ) {
987                    if ( nooption ) {
988                        transferoption = transferoption & ~TROPT_RFIO_O ;
989                    } else {
990#if defined(WITH_RFIO) || defined(WITH_RFIO64)
991                        transferoption = transferoption | TROPT_RFIO_O ;
992#else
993                        if (warning) printmessage(stderr,CASE_WARNING,20,timestamp,"Incorrect command : setoption localrfio (RFIO not supported)\n",buffercmd) ;
994#endif
995                    }
996                } else if ( !strncmp(startcmd,"keepmode",8) ) {
997                    if ( nooption ) {
998                        transferoption = transferoption & ~TROPT_MODE ;
999                    } else {
1000                        transferoption = transferoption | TROPT_MODE ;
1001                    }
1002                } else if ( !strncmp(startcmd,"keepaccess",10) ) {
1003                    if ( nooption ) {
1004                        transferoption = transferoption & ~TROPT_ACC ;
1005                    } else {
1006                        transferoption = transferoption | TROPT_ACC ;
1007                    }
1008                } else if ( !strncmp(startcmd,"gzip",4) ) {
1009                    if ( nooption ) {
1010                        transferoption = transferoption & ~TROPT_GZIP ;
1011                    } else {
1012#ifdef WITH_GZIP                       
1013                        transferoption = transferoption | TROPT_GZIP ;
1014#else
1015                        printmessage(stderr,CASE_FATAL_ERROR,7,timestamp,"gzip option is not available: bbftp was built without compression support\n") ;
1016#endif                       
1017                    }
1018                } else if ( !strncmp(startcmd,"qbss",4) ) {
1019                    if ( nooption ) {
1020                        transferoption = transferoption & ~TROPT_QBSS ;
1021                    } else {
1022                        transferoption = transferoption | TROPT_QBSS ;
1023                    }
1024                } else {
1025                    if ( warning ) printmessage(stderr,CASE_WARNING,20,timestamp,"Unkown option in .bbftprc file (%s)\n",startcmd) ;
1026                }
1027            } else {
1028                if ( warning ) printmessage(stderr,CASE_WARNING,13,timestamp,"Unkown command in .bbftprc file (%s)\n",startcmd) ;
1029            }
1030            carret++ ;
1031        }
1032    }
1033/*
1034** Check for input file or command line
1035*/
1036    if ( inputfile == NULL && bbftpcmd == NULL ) {
1037        printmessage(stderr,CASE_FATAL_ERROR,20,timestamp,"Error on command line (-i or -e option are mandatory)\n") ;
1038    }
1039/*
1040** Open the input file if needed
1041*/
1042    if ( inputfile != NULL ) {
1043        if ( (infd = open(inputfile,O_RDONLY)) < 0 ) {
1044            printmessage(stderr,CASE_FATAL_ERROR,21,timestamp,"Error opening input file (%s) : %s\n",inputfile,strerror(errno)) ;
1045        }
1046#ifdef DARWIN
1047                if ( (resfd = open(resultfile,O_CREAT|O_WRONLY|O_TRUNC,0777)) < 0 ) {
1048#else
1049        if ( (resfd = open(resultfile,O_CREAT|O_WRONLY|O_SYNC|O_TRUNC,0777)) < 0 ) {
1050#endif
1051                printmessage(stderr,CASE_FATAL_ERROR,22,timestamp,"Error opening result file (%s) : %s\n",resultfile,strerror(errno)) ;
1052        }
1053        /*
1054        ** Now calc the max line of the input file in order to malloc
1055        ** the buffer
1056        */
1057        maxlen = 0 ;
1058        j = 0 ;
1059        while ( (lengthread = read (infd,calcmaxline,1)) == 1 ) {
1060            if ( calcmaxline[0] == 10 ) {
1061                if ( j > maxlen ) {
1062                    maxlen = j  ;
1063                }
1064                j = 0 ;
1065            } else {
1066                j++ ;
1067            }
1068        }
1069        if ( lengthread < 0 ) {
1070            printmessage(stderr,CASE_FATAL_ERROR,24,timestamp,"Error reading input file (%s) : %s\n",inputfile,strerror(errno)) ;
1071        } else if ( lengthread == 0 ) {
1072            if ( j > maxlen ) {
1073                maxlen = j  ;
1074            }
1075        }
1076       /*
1077        ** Reset the file at start position
1078        */
1079        lseek(infd,0,SEEK_SET) ;
1080        if ( (buffercmd = (char *) malloc (maxlen+2) ) == NULL ) {
1081            printmessage(stderr,CASE_FATAL_ERROR,23,timestamp,"Unable to malloc memory for command : %s\n",strerror(errno)) ;
1082        }
1083    } else {
1084        if ( (buffercmd = (char *) malloc (strlen(bbftpcmd)+1)) == NULL ) {
1085             printmessage(stderr,CASE_FATAL_ERROR,23,timestamp,"Unable to malloc memory for command : %s\n",strerror(errno)) ;
1086         }
1087    }
1088     
1089/*
1090** Check hostname
1091*/         
1092    if ( optind == argc-1 ) {
1093        hostname= argv[optind] ;
1094    } else {
1095        /*
1096         * Maybe a TURL format: get hostname from command
1097         */
1098        maxlen = 0 ;
1099        retcode = 0 ;
1100        while (retcode == 0 ) {
1101            if ( inputfile != NULL ) {
1102                j = 0 ;
1103                while ( (lengthread = read (infd,&buffercmd[j],1)) == 1 ) {
1104                    if ( buffercmd[j] == 10 ) {
1105                        buffercmd[j] = 0 ;
1106                        break ;
1107                    } else {
1108                        j++ ;
1109                    }
1110                }
1111                if ( lengthread < 0 ) {
1112                    printmessage(stderr,CASE_FATAL_ERROR,24,timestamp,"Error reading input file (%s) : %s\n",inputfile,strerror(errno)) ;
1113                } else if ( lengthread == 0 ) {
1114                    if ( j == 0 ) {
1115                        retcode = 1 ;
1116                        break ;
1117                    } else {
1118                        buffercmd[j+1] = 0 ;
1119                    }
1120                }
1121            } else {
1122                /*
1123                ** the command may be under the form cmd ; cmd ; cmd....
1124                */
1125                j = 0 ;
1126                while ((maxlen < strlen(bbftpcmd)) && (bbftpcmd[maxlen] == ' ')) maxlen++ ;
1127                while ( (maxlen < strlen(bbftpcmd)) && (bbftpcmd[maxlen] != ';') ) {
1128                    buffercmd[j] =  bbftpcmd[maxlen] ;
1129                    j++ ;
1130                    maxlen++ ;
1131                }
1132                if ( maxlen == strlen(bbftpcmd) ) retcode = 1 ;
1133                maxlen++ ;
1134                buffercmd[j] = 0 ;
1135            }
1136            if ( translatecommand(buffercmd, &newcmd, &hostname, &newcontrolport, &remoterfio, &localrfio) == 0 ) {
1137                    if (localrfio == 1 && ((transferoption & TROPT_RFIO_O)!=TROPT_RFIO_O) ) {
1138                        addCommand("setoption localrfio");
1139                        transferoption = transferoption | TROPT_RFIO_O ;
1140                    } else if (localrfio == 0 && ((transferoption & TROPT_RFIO_O)==TROPT_RFIO_O) ) {
1141                        addCommand("setoption nolocalrfio");
1142                        transferoption = transferoption & ~TROPT_RFIO_O ;
1143                    }
1144                    if (remoterfio == 1 && ((transferoption & TROPT_RFIO)!=TROPT_RFIO) ) {
1145                        addCommand("setoption remoterfio");
1146                        if ( remotecos == -1 ) remotecos = 0 ;
1147                        transferoption = transferoption | TROPT_RFIO ;
1148                    } else if (remoterfio == 0 && ((transferoption & TROPT_RFIO)==TROPT_RFIO) ) {
1149                        addCommand("setoption noremoterfio");
1150                        transferoption = transferoption & ~TROPT_RFIO ;
1151                    }
1152                    addCommand(newcmd);
1153            } else {
1154                    printmessage(stderr,CASE_FATAL_ERROR,24,timestamp,"Unable to parse command  : %s\n",buffercmd) ;
1155            }
1156        }
1157        commandList = first;
1158    }
1159    if (hostname == NULL || strlen(hostname) == 0) {
1160        Usage() ;
1161        printmessage(stderr,CASE_FATAL_ERROR,14,timestamp,"No hostname on command line\n") ;
1162    }   
1163/*
1164** Check if hostname is in numeric format
1165*/
1166    for (j=0 ; j < strlen(hostname) ; j++) {
1167        if ( isalpha(hostname[j]) ) {
1168            /*
1169            ** One alpha caractere means no numeric form
1170            */
1171            hosttype = 1 ;
1172            break ;
1173        } else if ( isdigit(hostname[j]) ) {
1174        } else if ( hostname[j] == '.' ) {
1175        } else {
1176            printmessage(stderr,CASE_FATAL_ERROR,15,timestamp,"Invalid hostname (%s)\n",hostname) ;
1177        }
1178    }
1179    if ( hosttype == 0 ) {
1180       /*
1181       ** Numeric format
1182       */
1183        hisctladdr.sin_addr.s_addr = 0 ;
1184        hisctladdr.sin_addr.s_addr = inet_addr(hostname) ;
1185        if (hisctladdr.sin_addr.s_addr == -1 ) {
1186            printmessage(stderr,CASE_FATAL_ERROR,16,timestamp,"Invalid IP address (%s)\n",hostname) ;
1187        }
1188        calchostname = (char *)inet_ntoa(hisctladdr.sin_addr) ;
1189        if ( strcmp(hostname,calchostname) ) {
1190            printmessage(stderr,CASE_FATAL_ERROR,16,timestamp,"Invalid IP address (%s)\n",hostname) ;
1191        }
1192    } else {
1193       /*
1194       ** Alpha format
1195       */
1196        if ( (hp = gethostbyname((char *)hostname) ) == NULL ) {
1197            printmessage(stderr,CASE_FATAL_ERROR,17,timestamp,"Hostname no found (%s)\n",hostname) ;
1198        } else {
1199            if (hp->h_length > (int)sizeof(hisctladdr.sin_addr)) {
1200                hp->h_length = sizeof(hisctladdr.sin_addr);
1201            }
1202            memcpy(&hisctladdr.sin_addr, hp->h_addr_list[0], hp->h_length) ;
1203        }
1204    }
1205/*
1206** Check username if not in     certificate authentication mode
1207*/         
1208    if ( username == NULL ) {
1209#ifdef CERTIFICATE_AUTH
1210        if (usessh) {
1211/*            Usage() ;
1212            printmessage(stderr,CASE_FATAL_ERROR,18,timestamp,"No username given\n") ;*/
1213        } else {
1214            usecert = SETTOONE;
1215        }
1216#else       
1217        if (!usessh) {
1218            Usage() ;
1219            printmessage(stderr,CASE_FATAL_ERROR,18,timestamp,"No username given\n") ;
1220        }
1221#endif
1222    }
1223    if ( debug ) {
1224        if (simulation_mode) {
1225            printmessage(stdout,CASE_NORMAL,0,timestamp,"** SIMULATION MODE: No data written **\n") ;
1226        }
1227        printmessage(stdout,CASE_NORMAL,0,timestamp,"Starting parameters -----------------\n") ;
1228        printmessage(stdout,CASE_NORMAL,0,timestamp,"number of tries   = %d\n",globaltrymax) ;
1229        printmessage(stdout,CASE_NORMAL,0,timestamp,"number of streams = %d\n",nbport) ;
1230        printmessage(stdout,CASE_NORMAL,0,timestamp,"localumask        = %03o\n",localumask) ;
1231        printmessage(stdout,CASE_NORMAL,0,timestamp,"remoteumask       = %03o\n",remoteumask) ;
1232#if defined(WITH_RFIO) || defined(WITH_RFIO64)
1233        printmessage(stdout,CASE_NORMAL,0,timestamp,"localcos          = %d\n",localcos) ;
1234#endif
1235        printmessage(stdout,CASE_NORMAL,0,timestamp,"remotecos         = %d\n",remotecos) ;
1236        printmessage(stdout,CASE_NORMAL,0,timestamp,"buffersize        = %d KB\n",buffersizeperstream) ;
1237        printmessage(stdout,CASE_NORMAL,0,timestamp,"sendwinsize       = %d KB\n",sendwinsize) ;
1238        printmessage(stdout,CASE_NORMAL,0,timestamp,"recvwinsize       = %d KB\n",recvwinsize) ;
1239        printmessage(stdout,CASE_NORMAL,0,timestamp,"ackto                         = %d s\n",ackto) ;
1240        printmessage(stdout,CASE_NORMAL,0,timestamp,"recvcontrolto     = %d s\n",recvcontrolto) ;
1241        printmessage(stdout,CASE_NORMAL,0,timestamp,"sendcontrolto     = %d s\n",sendcontrolto) ;
1242        printmessage(stdout,CASE_NORMAL,0,timestamp,"datato     = %d s\n",datato) ;
1243                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_DIR ) == TROPT_DIR) ? "createdir" : "nocreatedir") ;
1244                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_TMP ) == TROPT_TMP) ? "tmpfile" : "notmpfile") ;
1245                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_RFIO ) == TROPT_RFIO) ? "remoterfio" : "noremoterfio") ;
1246#if defined(WITH_RFIO) || defined(WITH_RFIO64)
1247                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_RFIO_O ) == TROPT_RFIO_O) ? "localrfio" : "nolocalrfio") ;
1248#endif
1249                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_MODE ) == TROPT_MODE) ? "keepmode" : "nokeepmode") ;
1250                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_ACC ) == TROPT_ACC) ? "keepaccess" : "nokeepaccess") ;
1251#ifdef WITH_GZIP
1252                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_GZIP ) == TROPT_GZIP) ? "gzip" : "nogzip") ;
1253#endif       
1254                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_QBSS ) == TROPT_QBSS) ? "qbss" : "noqbss") ;
1255        printmessage(stdout,CASE_NORMAL,0,timestamp,"-------------------------------------\n") ;
1256        printmessage(stdout,CASE_NORMAL,0,timestamp,"Connection mode ---------------------\n") ;
1257        if ( usecert ) {
1258/*                      if ( username == NULL ) {*/
1259                                printmessage(stdout,CASE_NORMAL,0,timestamp,"Using certificate authentication\n") ;
1260/*                      } else {
1261                                printmessage(stdout,CASE_NORMAL,0,timestamp,"Using standard bbftp mode\n") ;
1262                        }*/
1263        } else if ( useprivate ) {
1264            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using private authentication\n") ;
1265        } else if ( usessh) {
1266            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using ssh mode\n") ;
1267            printmessage(stdout,CASE_NORMAL,0,timestamp,"     ssh command        = %s \n",sshcmd) ;
1268            printmessage(stdout,CASE_NORMAL,0,timestamp,"     ssh remote command = %s \n",sshremotecmd) ;
1269        } else {
1270            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using standard bbftp mode\n",localumask) ;
1271        }
1272        printmessage(stdout,CASE_NORMAL,0,timestamp,"-------------------------------------\n") ;
1273   }
1274
1275/*
1276** Ask for password if not in ssh mode
1277*/
1278#ifdef PRIVATE_AUTH
1279    if ( bbftp_private_getargs(logmessage) < 0 ) {
1280        printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Error while private authentication : %s\n",logmessage) ;
1281    }     
1282#else
1283    if ((!usessh && !usecert)/* || (usecert && username)*/) {
1284# ifdef AFS
1285        char *reasonString, passwordBuffer[1024] ;
1286        long code ;
1287        if ( (code = ka_UserReadPassword("Password: ", passwordBuffer, sizeof(passwordBuffer), &reasonString)) ) {
1288            printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Error while entering password\n") ;
1289        }
1290        if ( ( password = (char *) malloc (strlen(passwordBuffer) + 1) ) == NULL ) {
1291            printmessage(stderr,CASE_FATAL_ERROR,54,timestamp,"Unable to store password : malloc failed (%s)\n",strerror(errno)) ;
1292            return -1 ;
1293        }
1294        strcpy(password, passwordBuffer);
1295# else
1296#  ifdef USE_GETPASSPHRASE
1297        password = (char *) getpassphrase("Password: ") ;
1298        if ( strlen(password) == 0 ) {
1299            printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Password is mandatory\n") ;
1300        }
1301#  else
1302        printmessage(stdout,CASE_NORMAL,0,0,"Password: ") ;
1303        password = (char *) getpass("") ;
1304#  endif /* USE_GETPASSPHRASE */
1305# endif /* AFS */
1306    }
1307#endif
1308/*
1309** Set in background if required
1310*/
1311    if ( background ) {
1312        retcode = fork() ; 
1313        if ( retcode < 0 ) printmessage(stderr,CASE_FATAL_ERROR,31,timestamp,"Error forking while setting in background\n") ;
1314        if ( retcode > 0 ) exit(0) ;
1315        setsid() ;
1316        if ( verbose ) printmessage(stdout,CASE_NORMAL,0,timestamp,"Starting under pid %d\n",getpid());
1317    }
1318
1319/*
1320** Set the signals
1321*/
1322    bbftp_setsignals() ;
1323
1324/*
1325 * Analyze command list or command file to populate commandList
1326 */
1327    if (commandList == NULL) {
1328      maxlen = 0 ;
1329      retcode = 0 ;
1330      while (retcode == 0 ) {
1331        if ( inputfile != NULL ) {
1332            j = 0 ;
1333            while ( (lengthread = read (infd,&buffercmd[j],1)) == 1 ) {
1334                if ( buffercmd[j] == 10 ) {
1335                    buffercmd[j] = 0 ;
1336                    break ;
1337                } else {
1338                    j++ ;
1339                }
1340            }
1341            if ( lengthread < 0 ) {
1342                printmessage(stderr,CASE_FATAL_ERROR,24,timestamp,"Error reading input file (%s) : %s\n",inputfile,strerror(errno)) ;
1343            } else if ( lengthread == 0 ) {
1344                if ( j == 0 ) {
1345                    retcode = 1 ;
1346                    break ;
1347                } else {
1348                    buffercmd[j+1] = 0 ;
1349                }
1350            }
1351        } else {
1352            /*
1353            ** the command may be under the form cmd ; cmd ; cmd....
1354            */
1355            j = 0 ;
1356            while ((maxlen < strlen(bbftpcmd)) && (bbftpcmd[maxlen] == ' ')) maxlen++ ;
1357            while ( (maxlen < strlen(bbftpcmd)) && (bbftpcmd[maxlen] != ';') ) {
1358                buffercmd[j] =  bbftpcmd[maxlen] ;
1359                j++ ;
1360                maxlen++ ;
1361            }
1362            if ( maxlen == strlen(bbftpcmd) ) retcode = 1 ;
1363            buffercmd[j] = 0 ;
1364            maxlen++ ;
1365        }
1366        addCommand(buffercmd);
1367        if ( !strncmp(buffercmd,"setoption remoterfio",20) ) {
1368            if ( remotecos == -1 ) remotecos = 0;
1369        }
1370      }
1371      commandList = first;
1372    }
1373/*
1374** Now we've got all informations to make the connection
1375*/
1376
1377    if ( debug )
1378        printmessage(stdout,CASE_NORMAL,0,timestamp,"Connecting to server ----------------\n",localumask) ;
1379    reconnecttoserver() ;
1380    if ( debug )
1381         printmessage(stdout,CASE_NORMAL,0,timestamp,"Connecting end ---------------------\n",localumask) ;
1382   
1383/*
1384** Start the infinite loop
1385*/
1386    {
1387      cmd_list *iterator;
1388      iterator = commandList;
1389      while (iterator != NULL) {
1390        if ( treatcommand(iterator->cmd) == 0 ) {
1391            if ( inputfile != NULL ) {
1392                write(resfd,iterator->cmd,strlen(iterator->cmd)) ;               
1393                write(resfd," OK\n",4) ;
1394            } else {
1395                if (!verbose && !statoutput) printmessage(stdout,CASE_NORMAL,0,timestamp,"%s OK\n",iterator->cmd);
1396            }
1397        } else {
1398            if ( inputfile != NULL ) {
1399                write(resfd,iterator->cmd,strlen(iterator->cmd)) ;               
1400                write(resfd," FAILED\n",8) ;
1401            } else {
1402                if (!verbose && !statoutput) printmessage(stdout,CASE_NORMAL,0,timestamp,"%s FAILED\n",iterator->cmd);
1403            }
1404        }
1405        iterator = iterator->next;
1406      }
1407    }
1408    if ( inputfile != NULL ) {
1409        close(infd) ;
1410        close(resfd) ;
1411    }
1412    msg = (struct message *)minbuffer ;
1413    msg->code = MSG_CLOSE_CONN ;
1414    msg->msglen = 0 ;
1415    /*
1416    ** We do not care of the result because this routine is called
1417    ** only at the end of the client
1418    */
1419    writemessage(outcontrolsock,minbuffer,MINMESSLEN,sendcontrolto,0) ;
1420    sleep(1) ;
1421    bbftp_close_control() ;
1422    exit(myexitcode) ;
1423}
Note: See TracBrowser for help on using the repository browser.