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

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

Several more includes missing. Stand alone daemon/client are now built
with more warnings displayed.

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