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

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

bbftp_ndg.c will become the new entry point to the bbftp client, removing
lots of unnecessary code. This file isn't complete yet.

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 * This is a drop-in replacment for bbftp.c for use with NDG python embedding.
24 * Since it is largely based on the original bbftp code I have retained the original
25 * copyright.  Most sections from bbftp.c are not relevent when embedding in python
26 * and have been removed.
27 *
28 * @author Stephen Pascoe
29 */
30
31
32#include <bbftp.h>
33
34#include <errno.h>
35#include <fcntl.h>
36#include <netdb.h>
37#include <netinet/in.h>
38#include <pwd.h>
39#include <stdio.h>
40#include <sys/stat.h>
41#include <sys/types.h>
42#include <unistd.h>
43#if TIME_WITH_SYS_TIME
44# include <sys/time.h>
45# include <time.h>
46#else
47# if HAVE_SYS_TIME_H
48#  include <sys/time.h>
49# else
50#  include <time.h>
51# endif
52#endif
53#if HAVE_STRING_H
54# include <string.h>
55#endif
56
57#include <client.h>
58#include <client_proto.h>
59#include <common.h>
60#include <config.h>
61#include <structures.h>
62#include <version.h>
63
64#ifdef WITH_SSL
65#include <openssl/rsa.h>
66#endif
67
68#ifdef WITH_GZIP
69# include <zlib.h>
70#endif
71
72#define SETTOZERO    0
73#define SETTOONE     1
74
75#define SSHREMOTECMD "bbftpd -s"
76#define SSHCMD "ssh -q"
77
78#ifdef PRIVATE_AUTH
79#define OPTIONS "qbcde:f:i:l:mno:p:P:r:R:tu:vVw:WD::"
80#else
81#define OPTIONS "qbcde:E:f:g:i:I:l:L:mno:p:r:R:sStu:vVw:WD::"
82#endif
83/*
84#endif
85*/
86
87int     state   = SETTOZERO ;
88/*
89** timestamp:
90**      Every message on standart error and standart output are
91**      timestamped
92*/
93int     timestamp = SETTOZERO ;
94/*
95** protocolmin:
96**      Minimum protocol supportted
97*/
98int     protocolmin = 2 ; 
99int     protocolmax = 3 ; 
100int     protocol ;
101/*
102** debug:
103**      Set to one to print more debugging information
104*/
105int     debug = SETTOZERO ;
106/*
107** verbose:
108**      Set to one to print  information
109*/
110int     verbose = SETTOZERO ;
111/*
112** warning:
113**      Set to one to print warning to stderr
114*/
115int     warning = SETTOZERO ;
116/*
117** statoutput:
118**      Set to one for special output
119*/
120int     statoutput = SETTOZERO ;
121/*
122** globaltrymax:
123**      Number of try in case or recoverable error
124*/
125int     globaltrymax = NBTRYMAX ;
126/*
127** newcontrolport:
128**      Control port to be used
129*/
130int     newcontrolport = CONTROLPORT ;
131/*
132** usessh:
133**      Set to one when using ssh to start the remote daemon
134*/
135int     usessh = SETTOZERO ;
136/*
137** sshbatchmode:
138**      This is set to non-zero if running in batch mode (that is, password
139**      and passphrase queries are not allowed).
140*/
141int     sshbatchmode  = SETTOZERO ;
142/*
143** sshchildpid:
144**      To keep the ssh child pid
145*/
146int     sshchildpid   = SETTOZERO ;
147/*
148** For ssh
149*/
150char    *sshidentityfile = NULL ;
151char    *sshremotecmd = NULL ;
152char    *sshcmd = NULL ;
153/*
154** usecert:
155**              Set to one if using certificate authentifaction
156*/
157int             usecert = SETTOZERO ;
158/*
159** useprivate:
160**      Set to one if using private authentication
161*/
162int     useprivate = SETTOZERO ;
163/*
164** privatestr:
165**      Pointer to a private string used for private authentication
166**
167*/
168char    *privatestr = NULL ;
169/*
170** hisctladdr:
171**      the remote address
172*/
173struct sockaddr_in hisctladdr ;
174/*
175** myctladdr:
176**      the local address
177*/
178struct sockaddr_in myctladdr ;
179/*
180** bbftprc:
181**      Where to store the bbftprc file
182*/
183char    *bbftprc = NULL ;
184/*
185** Variable defining the local options :
186**
187** localcos:
188**      Value of the local class of service (in case of RFIO ability)
189**
190** localumask:
191**      Local umask taken by the umask command at start and
192**      modified by the setlocalumask command
193**
194** localrfio:
195**      set to one when using rfio for local files
196**
197*/
198int     localumask ;
199#if defined(WITH_RFIO) || defined(WITH_RFIO64)
200int     localcos  = SETTOZERO ;
201#endif
202
203char *newcmd = NULL;
204int remoterfio;
205int localrfio;
206/*
207** Variables defining both side options :
208**
209** usetmpfile:
210**      Set to one when using tmpname for file creation
211**
212** usegzipcompress:
213**      Set to one when using tmpname for file creation
214**
215** keepaccess:
216**      Set to one when keeping access time and modification
217**
218** keepmode:
219**      Set to one when keeping file mode
220**
221** creatdir:
222**      Set to one when automatic directory creation is needed
223*/
224int     sendwinsize     = 256 ;
225int     recvwinsize     = 256 ;
226int     nbport = 1 ;
227int             ackto                   = ACKTO;
228int             recvcontrolto   = CONTROLSOCKTO;
229int             sendcontrolto   = SENDCONTROLTO;
230int             datato                  = DATASOCKTO;
231
232/*
233** Variables remote side options :
234**
235** remoterfio:
236**      Set to one when rfio for remote file
237**
238** remoteumask:
239**      if set to zero do not set remote umask
240**
241** remotecos:
242**      if not set to zero do set remote cos
243**
244** remotedir :
245**      if not set to NULL change dir after connection
246**
247*/
248int     remoteumask = SETTOZERO ;
249int     remotecos   = -1 ;
250char    *remotedir = NULL ;
251/*
252** incontrolsock :
253**      Define the control socket for reading
254** outcontrolsock :
255**      Define the control socket for writing
256**
257**      For normal use : incontrolsock = outcontrolsock
258*/
259int     incontrolsock ;
260int     outcontrolsock ;
261/*
262** myexitcode :
263**      Contains the first error code that has to be return when program
264**      is ended
265*/
266int     myexitcode = SETTOZERO ;
267char    *hostname   = NULL ;
268struct hostent  *hp = NULL ;
269char    *username   = NULL ;
270char    *password   = NULL ;
271/*
272** mychildren :
273**      Pointer to the first pid of children
274*/
275int     *mychildren = NULL ;
276/*
277** nbpidchid :
278**      Number of pid pointed by mychildren
279*/
280int     nbpidchild ;
281/*
282** castfd:
283**      CASTOR file descriptor
284*/
285#ifdef CASTOR
286int     castfd = -1 ;
287char    *castfilename = NULL ;
288#endif
289
290/*
291** Parameters describing the transfer ********************
292*/
293int     transferoption = TROPT_TMP | TROPT_DIR | TROPT_MODE | TROPT_ACC; 
294int     filemode ;
295char    lastaccess[9] ;
296char    lastmodif[9] ;
297int     buffersizeperstream = 256 ;
298int     requestedstreamnumber ;
299my64_t  filesize ;
300/*
301** curfilename :
302**      Define the pointer to the current file
303*/
304char    *curfilename = NULL ;
305/*
306** realfilename :
307**      Define the pointer to the real file (= curfilename if TROPT_TMP not
308**      set)
309*/
310char    *realfilename   = NULL ;
311int     *myports        = NULL ;
312int     *mysockets      = NULL ;
313char    *readbuffer     = NULL ;
314char    *compbuffer     = NULL ; 
315int     resfd = -1 ;
316/*
317** Simulation mode (option -n)
318*/
319int             simulation_mode = SETTOZERO;
320/*
321**
322*/
323int connectionisbroken = SETTOZERO ;
324
325/*
326 * Range for the ephemeral ports for data connections
327 */
328int     pasvport_min = 0 ;
329int     pasvport_max = 0 ;
330
331/** Reset all global variables to how they were first initialised.
332 */
333void bbftpc_reset_globals(void) {
334
335  state   = SETTOZERO ;
336  timestamp = SETTOZERO ;
337 
338  protocolmin = 2 ; 
339  protocolmax = 3 ; 
340  //int     protocol ;
341  debug = SETTOZERO ;
342  verbose = SETTOZERO ;
343  warning = SETTOZERO ;
344  statoutput = SETTOZERO ;
345  globaltrymax = NBTRYMAX ;
346  newcontrolport = CONTROLPORT ;
347  usessh = SETTOZERO ;
348  sshbatchmode  = SETTOZERO ;
349  sshchildpid   = SETTOZERO ;
350  sshidentityfile = NULL ;
351  sshremotecmd = NULL ;
352  sshcmd = NULL ;
353 
354  usecert = SETTOZERO ;
355  useprivate = SETTOZERO ;
356  privatestr = NULL ;
357 
358  //struct sockaddr_in hisctladdr ;
359  //struct sockaddr_in myctladdr ;
360  bbftprc = NULL ;
361  //int     localumask ;
362#if defined(WITH_RFIO) || defined(WITH_RFIO64)
363  localcos  = SETTOZERO ;
364#endif
365 
366  newcmd = NULL;
367  //int remoterfio;
368  //int localrfio;
369  sendwinsize     = 256 ;
370  recvwinsize     = 256 ;
371  nbport = 1 ;
372  ackto                 = ACKTO;
373  recvcontrolto = CONTROLSOCKTO;
374  sendcontrolto = SENDCONTROLTO;
375  datato                        = DATASOCKTO;
376 
377  remoteumask = SETTOZERO ;
378  remotecos   = -1 ;
379  remotedir = NULL ;
380  //int     incontrolsock ;
381  //int     outcontrolsock ;
382  myexitcode = SETTOZERO ;
383  hostname   = NULL ;
384  hp = NULL ;
385  username   = NULL ;
386  password   = NULL ;
387  mychildren = NULL ;
388  //int     nbpidchild ;
389#ifdef CASTOR
390  castfd = -1 ;
391  castfilename = NULL ;
392#endif
393  transferoption = TROPT_TMP | TROPT_DIR | TROPT_MODE | TROPT_ACC; 
394  filemode ;
395  lastaccess[9] ;
396  lastmodif[9] ;
397  buffersizeperstream = 256 ;
398  //int     requestedstreamnumber ;
399  //my64_t  filesize ;
400  curfilename = NULL ;
401  realfilename   = NULL ;
402  myports        = NULL ;
403  mysockets      = NULL ;
404  readbuffer     = NULL ;
405  compbuffer     = NULL ; 
406  resfd = -1 ;
407  simulation_mode = SETTOZERO;
408 
409  connectionisbroken = SETTOZERO ;
410 
411  pasvport_min = 0 ;
412  pasvport_max = 0 ;
413 
414  commandList = NULL;
415  first = NULL;
416  iterator = NULL;
417}
418
419
420
421bbftpc_main(int argc, char **argv, char **envp) {
422  bbftpc_reset_globals();
423 
424  extern char *optarg;
425  extern int optind, opterr, optopt;
426/*
427** Variable set by options
428*/
429    char    *inputfile  = NULL ;
430    char    *resultfile = NULL ;
431    char    *outputfile = NULL ;
432    char    *errorfile  = NULL ;
433    char    *bbftpcmd   = NULL ;
434    int     background  = SETTOZERO ;
435/*
436** For hostname
437*/ 
438    int     hosttype = 0 ;
439    char    *calchostname ;
440/*
441** For local user
442*/
443    struct  passwd  *mypasswd ;
444    char    *bbftprcfile = NULL ;
445    int     fd ;
446    char    *carret ;
447    char    *startcmd ;
448    int     nooption ;
449   
450    struct  stat    statbuf ;
451    int     retcode ;
452    int     i, j, k ;
453    int     stderrfd ;
454    int     stdoutfd ;
455    int     infd ;
456    char    calcmaxline[1] ;
457    int     maxlen ;
458    int     lengthread ;
459    char    *buffercmd ;
460    int     alluse ;
461    char    *tmpsshremotecmd ;
462    char    logmessage[1024] ;
463    char    minbuffer[MINMESSLEN] ;
464    struct  message *msg ;
465/*
466** Get local umask
467*/
468    localumask = umask(0) ;
469/*
470** and reset it to the correct value
471*/
472    umask(localumask) ;
473/*
474** First check for timestamp in order to have a common output
475*/
476    opterr = 0 ;
477    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
478        switch (j) {
479            case 't' :{
480                timestamp = SETTOONE ;
481                break ;
482            }
483        }
484    }
485
486    useprivate = SETTOONE ;
487    usessh = SETTOZERO ;
488
489/*
490** Check for -v option
491*/
492    opterr = 0 ;
493    optind = 1 ;
494    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
495        switch (j) {
496            case 'v' :{
497                printmessage(stdout,CASE_NORMAL,0,timestamp,"bbftp version %s\n",VERSION) ;
498                printmessage(stdout,CASE_NORMAL,0,timestamp,"Compiled with  :   default port %d\n",CONTROLPORT) ;
499#ifdef PORT_RANGE
500                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   data ports range = %s \n", PORT_RANGE) ;
501#endif
502#ifdef WITH_GZIP
503                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   compression with Zlib-%s\n", zlibVersion()) ;
504#endif
505#ifdef WITH_SSL
506                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   encryption with %s \n",SSLeay_version(SSLEAY_VERSION)) ;
507#endif
508#ifdef WITH_RFIO
509# ifdef CASTOR
510                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   CASTOR support (RFIO)\n") ;
511# else
512                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   HPSS support (RFIO)\n") ;
513# endif
514#endif
515#ifdef WITH_RFIO64
516# ifdef CASTOR
517                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   CASTOR support (RFIO64)\n") ;
518# else
519                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   HPSS support (RFIO64)\n") ;
520# endif
521#endif
522#ifdef AFS
523                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   AFS authentication \n") ;
524#endif
525#ifdef PRIVATE_AUTH
526                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   private authentication \n") ;
527#else
528                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default ssh command = %s \n",SSHCMD) ;
529                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default ssh remote command = %s \n",SSHREMOTECMD) ;
530#endif
531#ifdef NDG_PYTHON_EMBED
532                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   Embedded in Python interpreter\n") ;
533#endif // NDG_PYTHON_EMBED
534
535                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default number of tries = %d  \n",NBTRYMAX) ;
536                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default sendwinsize = %d Kbytes\n",sendwinsize) ;
537                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default recvwinsize = %d Kbytes\n",recvwinsize) ;
538                printmessage(stdout,CASE_NORMAL,0,timestamp,"                   default number of stream = %d \n",nbport) ;
539                exit(0) ;
540            }
541        }
542    }
543
544    /**
545     * @todo replace getopt arguments with python calls.
546     */
547
548/*
549** Now all the others
550*/
551    opterr = 0 ;
552    optind = 1 ;
553    while ((j = getopt(argc, argv, OPTIONS)) != -1) {
554        switch (j) {
555            case 'b' :{
556                background = SETTOONE ;
557                break ;
558            }
559            case 'c' :{
560#ifdef WITH_GZIP               
561                transferoption = transferoption | TROPT_GZIP ;
562#else
563                printmessage(stderr,CASE_FATAL_ERROR,7,timestamp,"option -c is not available: bbftp was built without compression utility\n") ;
564#endif               
565                break ;
566            }
567            case 'd' :{
568                debug = 1 ;
569                break ;
570            }
571            case 'D' :{         
572                if (optarg) {
573                    if ((sscanf(optarg,"%d:%d",&i, &k) == 2) && (i < k)) {
574                        pasvport_min = i; pasvport_max = k;
575                    } else {
576                        printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Invalid port range : %s\n",optarg) ;
577                    }
578                } else {
579#ifdef PORT_RANGE
580                     sscanf(PORT_RANGE,"%d:%d",&pasvport_min, &pasvport_max) ;
581#endif
582                     if (0 == pasvport_max) {
583                         pasvport_min = 0;
584                         pasvport_max = 1;
585                     }
586                }
587                protocolmax = 2 ;
588                break ;
589            }
590            case 'e' : {
591                bbftpcmd = optarg ;
592                break ;
593            }
594            case 'E' : {
595                sshremotecmd = optarg ;
596                usessh = 1 ;
597                break ;
598            }
599            case 'f' :{
600                errorfile = optarg ;
601                break ;
602            }
603            case 'i' :{
604                inputfile = optarg ;
605                if ( stat (inputfile,&statbuf) < 0 ) {
606                    printmessage(stderr,CASE_FATAL_ERROR,7,timestamp,"Input file (%s) cannot be stated\n",inputfile) ;
607                }
608                if ( (resultfile = (char *) malloc (strlen(inputfile) + 5 )) == NULL ) {
609                    printmessage(stderr,CASE_FATAL_ERROR,1,timestamp,"Cannot malloc space for result file name\n") ;
610                }
611                strcpy(resultfile,inputfile) ;
612                strcat(resultfile,".res") ;
613                break ;
614            }
615            case 'I' :{
616                sshidentityfile = optarg ;
617                usessh = 1 ;
618                /*
619                ** Check if file exists
620                */
621                if ( stat (sshidentityfile,&statbuf) < 0 ) {
622                    printmessage(stderr,CASE_FATAL_ERROR,5,timestamp,"SSH identity file (%s) cannot be stated\n",sshidentityfile) ;
623                }
624                break ;
625            }
626            case 'L' : {
627                sshcmd = optarg ;
628                usessh = 1 ;
629                break ;
630            }
631            case 'm' :{
632                statoutput = SETTOONE ;
633                break ;
634            }
635            case 'n':{
636                simulation_mode = SETTOONE ;
637                break ;
638            }
639            case 'o' :{
640                outputfile = optarg ;
641                break ;
642            }
643            case 'P' :{
644                privatestr = optarg ;
645                break ;
646            }
647            case 'q' :{
648                transferoption = transferoption | TROPT_QBSS ;
649                                break ;
650                        }
651            case 'p' :{
652                retcode = sscanf(optarg,"%d",&alluse) ;
653                if ( retcode != 1 || alluse < 0) {
654                    printmessage(stderr,CASE_FATAL_ERROR,3,timestamp,"Number of streams must be numeric and > 0\n") ;
655                }
656                nbport = alluse ;
657                break ;
658            }
659            case 'r' :{
660                retcode = sscanf(optarg,"%d",&alluse) ;
661                if ( retcode != 1 || alluse <= 0) {
662                    printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Number of tries must be numeric > 0\n") ;
663                }
664                globaltrymax = alluse ;
665                break ;
666            }
667            case 'R' :{
668                bbftprcfile = optarg ;
669                break ;
670            }
671            case 's' :{
672                usessh = SETTOONE ;
673                break ;
674            }
675            case 'S' :{
676                usessh = SETTOONE ;
677                sshbatchmode = SETTOONE ;
678                break ;
679            }
680            case 't' :{
681                timestamp = SETTOONE ;
682                break ;
683            }
684            case 'u' :{
685                username = optarg ;
686                break ;
687            }
688            case 'V':{
689                verbose = SETTOONE ;
690                break ;
691            }
692            case 'w' :{
693                retcode = sscanf(optarg,"%d",&alluse) ;
694                if ( retcode != 1 || alluse <= 0) {
695                    printmessage(stderr,CASE_FATAL_ERROR,4,timestamp,"Control port must be numeric\n") ;
696                }
697                newcontrolport = alluse ;
698                break ;
699            }
700            case 'W':{
701                warning = SETTOONE ;
702                break ;
703            }
704            default : {
705                Usage() ;
706                printmessage(stderr,CASE_FATAL_ERROR,6,timestamp,"Error on command line (unsupported option -%c)\n",optopt) ;
707            }
708        }
709    }
710    /*
711    ** Get 5K for castfilename in order to work with CASTOR
712    ** software (even if we are not using it)
713    */
714#ifdef CASTOR
715    if ( (castfilename = (char *) malloc (5000)) == NULL ) {
716        /*
717        ** Starting badly if we are unable to malloc 5K
718        */
719        printmessage(stderr,CASE_FATAL_ERROR,10,timestamp,"No memory for CASTOR : %s\n",strerror(errno)) ;
720    }
721#endif
722
723    /*
724    ** Reset all outputs variable if statoutput is set to one
725    */
726    if ( statoutput ) {
727        debug     = SETTOZERO ;
728        verbose   = SETTOZERO ;
729        warning   = SETTOZERO ;
730        timestamp = SETTOZERO ;
731    }
732 
733/*
734** Check all ssh stuff
735*/
736    if ( usessh) {
737        if ( sshremotecmd == NULL ) {
738            /*
739            ** Malloc space and set the default
740            */
741            if ( (sshremotecmd = (char *) malloc (strlen(SSHREMOTECMD)+1) ) == NULL ) {
742                printmessage(stderr,CASE_FATAL_ERROR,8,timestamp,"Cannot malloc space for ssh remote cmd\n") ;
743            }
744            strcpy(sshremotecmd,SSHREMOTECMD) ;
745        } else {
746            /*
747            ** Verify if -s is present if not add it (in order to fit v 1.9.4-tja1
748            ** behaviour)
749            */
750            if ( strstr(sshremotecmd," -s") == NULL ) {
751                if ( ( tmpsshremotecmd = (char *) malloc (strlen(sshremotecmd) + 4) ) == NULL ) {
752                    printmessage(stderr,CASE_FATAL_ERROR,8,timestamp,"Cannot malloc space for ssh remote cmd\n") ;
753                }
754                sprintf(tmpsshremotecmd,"%s -s",sshremotecmd) ;
755                sshremotecmd = tmpsshremotecmd ;
756            }
757        }
758        if ( sshcmd == NULL ) {
759            if ( (sshcmd = (char *) malloc (strlen(SSHCMD)+1) ) == NULL ) {
760                  printmessage(stderr,CASE_FATAL_ERROR,9,timestamp,"Cannot malloc space for ssh cmd\n") ;
761            }
762            strcpy(sshcmd,SSHCMD) ;
763        }
764    }
765
766
767    /**
768     * @todo replace hostname code with something better.
769     */
770     
771/*
772** Check hostname
773*/         
774    if ( optind == argc-1 ) {
775        hostname= argv[optind] ;
776    } else {
777      printmessage(stderr,CASE_FATAL_ERROR,24,timestamp,"Unable to find hostname\n");
778
779    if (hostname == NULL || strlen(hostname) == 0) {
780        Usage() ;
781        printmessage(stderr,CASE_FATAL_ERROR,14,timestamp,"No hostname on command line\n") ;
782    }   
783/*
784** Check if hostname is in numeric format
785*/
786    for (j=0 ; j < strlen(hostname) ; j++) {
787        if ( isalpha(hostname[j]) ) {
788            /*
789            ** One alpha caractere means no numeric form
790            */
791            hosttype = 1 ;
792            break ;
793        } else if ( isdigit(hostname[j]) ) {
794        } else if ( hostname[j] == '.' ) {
795        } else {
796            printmessage(stderr,CASE_FATAL_ERROR,15,timestamp,"Invalid hostname (%s)\n",hostname) ;
797        }
798    }
799    if ( hosttype == 0 ) {
800       /*
801       ** Numeric format
802       */
803        hisctladdr.sin_addr.s_addr = 0 ;
804        hisctladdr.sin_addr.s_addr = inet_addr(hostname) ;
805        if (hisctladdr.sin_addr.s_addr == -1 ) {
806            printmessage(stderr,CASE_FATAL_ERROR,16,timestamp,"Invalid IP address (%s)\n",hostname) ;
807        }
808        calchostname = (char *)inet_ntoa(hisctladdr.sin_addr) ;
809        if ( strcmp(hostname,calchostname) ) {
810            printmessage(stderr,CASE_FATAL_ERROR,16,timestamp,"Invalid IP address (%s)\n",hostname) ;
811        }
812    } else {
813       /*
814       ** Alpha format
815       */
816        if ( (hp = gethostbyname((char *)hostname) ) == NULL ) {
817            printmessage(stderr,CASE_FATAL_ERROR,17,timestamp,"Hostname no found (%s)\n",hostname) ;
818        } else {
819            if (hp->h_length > (int)sizeof(hisctladdr.sin_addr)) {
820                hp->h_length = sizeof(hisctladdr.sin_addr);
821            }
822            memcpy(&hisctladdr.sin_addr, hp->h_addr_list[0], hp->h_length) ;
823        }
824    }
825/*
826** Check username if not in     certificate authentication mode
827*/         
828    if ( username == NULL ) {
829        if (!usessh) {
830            Usage() ;
831            printmessage(stderr,CASE_FATAL_ERROR,18,timestamp,"No username given\n") ;
832        }
833    }
834    if ( debug ) {
835        if (simulation_mode) {
836            printmessage(stdout,CASE_NORMAL,0,timestamp,"** SIMULATION MODE: No data written **\n") ;
837        }
838        printmessage(stdout,CASE_NORMAL,0,timestamp,"Starting parameters -----------------\n") ;
839        printmessage(stdout,CASE_NORMAL,0,timestamp,"number of tries   = %d\n",globaltrymax) ;
840        printmessage(stdout,CASE_NORMAL,0,timestamp,"number of streams = %d\n",nbport) ;
841        printmessage(stdout,CASE_NORMAL,0,timestamp,"localumask        = %03o\n",localumask) ;
842        printmessage(stdout,CASE_NORMAL,0,timestamp,"remoteumask       = %03o\n",remoteumask) ;
843#if defined(WITH_RFIO) || defined(WITH_RFIO64)
844        printmessage(stdout,CASE_NORMAL,0,timestamp,"localcos          = %d\n",localcos) ;
845#endif
846        printmessage(stdout,CASE_NORMAL,0,timestamp,"remotecos         = %d\n",remotecos) ;
847        printmessage(stdout,CASE_NORMAL,0,timestamp,"buffersize        = %d KB\n",buffersizeperstream) ;
848        printmessage(stdout,CASE_NORMAL,0,timestamp,"sendwinsize       = %d KB\n",sendwinsize) ;
849        printmessage(stdout,CASE_NORMAL,0,timestamp,"recvwinsize       = %d KB\n",recvwinsize) ;
850        printmessage(stdout,CASE_NORMAL,0,timestamp,"ackto                         = %d s\n",ackto) ;
851        printmessage(stdout,CASE_NORMAL,0,timestamp,"recvcontrolto     = %d s\n",recvcontrolto) ;
852        printmessage(stdout,CASE_NORMAL,0,timestamp,"sendcontrolto     = %d s\n",sendcontrolto) ;
853        printmessage(stdout,CASE_NORMAL,0,timestamp,"datato     = %d s\n",datato) ;
854                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_DIR ) == TROPT_DIR) ? "createdir" : "nocreatedir") ;
855                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_TMP ) == TROPT_TMP) ? "tmpfile" : "notmpfile") ;
856                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_RFIO ) == TROPT_RFIO) ? "remoterfio" : "noremoterfio") ;
857#if defined(WITH_RFIO) || defined(WITH_RFIO64)
858                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_RFIO_O ) == TROPT_RFIO_O) ? "localrfio" : "nolocalrfio") ;
859#endif
860                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_MODE ) == TROPT_MODE) ? "keepmode" : "nokeepmode") ;
861                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_ACC ) == TROPT_ACC) ? "keepaccess" : "nokeepaccess") ;
862#ifdef WITH_GZIP
863                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_GZIP ) == TROPT_GZIP) ? "gzip" : "nogzip") ;
864#endif       
865                printmessage(stdout,CASE_NORMAL,0,timestamp,"option %s\n", ((transferoption & TROPT_QBSS ) == TROPT_QBSS) ? "qbss" : "noqbss") ;
866        printmessage(stdout,CASE_NORMAL,0,timestamp,"-------------------------------------\n") ;
867        printmessage(stdout,CASE_NORMAL,0,timestamp,"Connection mode ---------------------\n") ;
868        if ( usecert ) {
869/*                      if ( username == NULL ) {*/
870                                printmessage(stdout,CASE_NORMAL,0,timestamp,"Using certificate authentication\n") ;
871/*                      } else {
872                                printmessage(stdout,CASE_NORMAL,0,timestamp,"Using standard bbftp mode\n") ;
873                        }*/
874        } else if ( useprivate ) {
875            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using private authentication\n") ;
876        } else if ( usessh) {
877            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using ssh mode\n") ;
878            printmessage(stdout,CASE_NORMAL,0,timestamp,"     ssh command        = %s \n",sshcmd) ;
879            printmessage(stdout,CASE_NORMAL,0,timestamp,"     ssh remote command = %s \n",sshremotecmd) ;
880        } else {
881            printmessage(stdout,CASE_NORMAL,0,timestamp,"Using standard bbftp mode\n",localumask) ;
882        }
883        printmessage(stdout,CASE_NORMAL,0,timestamp,"-------------------------------------\n") ;
884   }
885
886/*
887** Ask for password if not in ssh mode
888*/
889#ifdef PRIVATE_AUTH
890    if ( bbftp_private_getargs(logmessage) < 0 ) {
891        printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Error while private authentication : %s\n",logmessage) ;
892    }     
893#else
894    if ((!usessh && !usecert)/* || (usecert && username)*/) {
895# ifdef AFS
896        char *reasonString, passwordBuffer[1024] ;
897        long code ;
898        if ( (code = ka_UserReadPassword("Password: ", passwordBuffer, sizeof(passwordBuffer), &reasonString)) ) {
899            printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Error while entering password\n") ;
900        }
901        if ( ( password = (char *) malloc (strlen(passwordBuffer) + 1) ) == NULL ) {
902            printmessage(stderr,CASE_FATAL_ERROR,54,timestamp,"Unable to store password : malloc failed (%s)\n",strerror(errno)) ;
903            return -1 ;
904        }
905        strcpy(password, passwordBuffer);
906# else
907#  ifdef USE_GETPASSPHRASE
908        password = (char *) getpassphrase("Password: ") ;
909        if ( strlen(password) == 0 ) {
910            printmessage(stderr,CASE_FATAL_ERROR,19,timestamp,"Password is mandatory\n") ;
911        }
912#  else
913        printmessage(stdout,CASE_NORMAL,0,0,"Password: ") ;
914        password = (char *) getpass("") ;
915#  endif /* USE_GETPASSPHRASE */
916# endif /* AFS */
917    }
918#endif
919
920/*
921** Set the signals
922*/
923    bbftp_setsignals() ;
924
925
926    if ( debug )
927        printmessage(stdout,CASE_NORMAL,0,timestamp,"Connecting to server ----------------\n",localumask) ;
928    reconnecttoserver() ;
929    if ( debug )
930         printmessage(stdout,CASE_NORMAL,0,timestamp,"Connecting end ---------------------\n",localumask) ;
931   
932/*
933** Start the infinite loop
934*/
935    {
936      cmd_list *iterator;
937      iterator = commandList;
938      while (iterator != NULL) {
939        if ( treatcommand(iterator->cmd) == 0 ) {
940            if ( inputfile != NULL ) {
941                write(resfd,iterator->cmd,strlen(iterator->cmd)) ;               
942                write(resfd," OK\n",4) ;
943            } else {
944                if (!verbose && !statoutput) printmessage(stdout,CASE_NORMAL,0,timestamp,"%s OK\n",iterator->cmd);
945            }
946        } else {
947            if ( inputfile != NULL ) {
948                write(resfd,iterator->cmd,strlen(iterator->cmd)) ;               
949                write(resfd," FAILED\n",8) ;
950            } else {
951                if (!verbose && !statoutput) printmessage(stdout,CASE_NORMAL,0,timestamp,"%s FAILED\n",iterator->cmd);
952            }
953        }
954        iterator = iterator->next;
955      }
956    }
957    if ( inputfile != NULL ) {
958        close(infd) ;
959        close(resfd) ;
960    }
961    msg = (struct message *)minbuffer ;
962    msg->code = MSG_CLOSE_CONN ;
963    msg->msglen = 0 ;
964    /*
965    ** We do not care of the result because this routine is called
966    ** only at the end of the client
967    */
968    writemessage(outcontrolsock,minbuffer,MINMESSLEN,sendcontrolto,0) ;
969    sleep(1) ;
970    bbftp_close_control() ;
971#ifndef NDG_PYTHON_EMBED
972    exit(myexitcode) ;
973#endif
974}
Note: See TracBrowser for help on using the repository browser.