source: TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/bbftpd_readcontrol.c @ 1328

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/bbftpd_readcontrol.c@1328
Revision 1328, 51.4 KB checked in by spascoe, 13 years ago (diff)

I've created a bbftpd log facility to replace syslog.
At present it allows you to log messages to a file in addition
to syslog. This should help testing on other machines.

Line 
1/*
2 * bbftpd/bbftpd_readcontrol.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 RETURN:
26         0  calling program return to main loop
27        -1 calling program exit
28 
29 bbftpd_readcontrol.c   v 2.0.0 2000/12/19  - Routine creation
30                        v 2.0.1 2001/04/23  - Correct indentation
31                        v 2.0.2 2001/05/04  - Correct return code treatment
32                                            - Correct case of file size 0
33                        v 2.1.0 2001/05/30  - Correct bbftpd_log level
34                                            - Change routines name
35                        v 2.2.0 2001/11/21  - Remote COS received can be -1
36               
37*****************************************************************************/
38#include <bbftpd.h>
39
40#include <errno.h>
41
42#include <stdio.h>
43#include <bbftpd_log.h>
44#include <utime.h>
45#include <sys/types.h>
46#include <unistd.h>
47#if HAVE_STRING_H
48# include <string.h>
49#endif
50
51#include <netinet/in.h>
52#include <common.h>
53#include <daemon.h>
54#include <daemon_proto.h>
55#include <status.h>
56#include <structures.h>
57#include <version.h>
58
59extern int  state ;
60extern int  incontrolsock ;
61extern int  outcontrolsock ;
62extern  int     recvcontrolto ;
63extern  int     sendcontrolto ;
64extern char *curfilename ;
65extern char *realfilename ;
66extern int  curfilenamelen ;
67extern int  transferoption ;
68extern int  filemode ;
69extern char lastaccess[9] ;
70extern char lastmodif[9] ;
71extern int  sendwinsize ;       
72extern int  recvwinsize ;       
73extern int  buffersizeperstream ;
74extern int  requestedstreamnumber ;
75extern my64_t  filesize ;
76extern int  *myports ;
77extern int  *mychildren ;
78extern int  *mysockets ;
79extern int  myumask ;
80extern int  mycos ;
81extern char *readbuffer ;
82extern char *compbuffer ;
83extern int  protocolversion ;
84extern  char            currentusername[MAXLEN] ;
85
86#ifndef WORDS_BIGENDIAN
87# ifndef HAVE_NTOHLL
88my64_t    ntohll(my64_t v) ;
89# endif
90#endif
91
92int bbftpd_readcontrol(int msgcode,int msglen) 
93{
94
95    int        retcode ;
96    int        i ;
97    char    *receive_buffer ;
98    int     oldumask, newumask ;
99    struct  message *msg ;
100    struct  mess_store_v2 *msg_store_v2 ;
101    struct  mess_integer *msg_integer ;
102    struct  mess_dir *msg_dir ;
103    char    logmessage[1024] ;
104    int     *portfree ;
105    struct utimbuf ftime ;
106    int     *porttosend ;   
107    /*
108    ** Depending on the state the accepted message may be different
109    */
110#ifndef WORDS_BIGENDIAN
111    msglen = ntohl(msglen) ;
112#endif
113    switch (state) {
114        /*
115        ** Case S_LOGGED :
116        **      Nothing is going on, so message accepted are :
117        **
118        **         MSG_CHCOS
119        **         MSG_CHDIR_V2
120        **         MSG_CHUMASK
121        **         MSG_CLOSE_CONN
122        **         MSG_LIST_V2
123        **         MSG_MKDIR_V2
124        **         MSG_RETR_V2
125        **         MSG_STORE_V2
126        **
127        */
128           case S_LOGGED : {
129            switch (msgcode) {
130           
131                case MSG_CHCOS : {
132                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CHCOS, msglen = %d",msglen) ;
133                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
134                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_CHCOS : %s",strerror(errno)) ;
135                        reply(MSG_BAD,"Error allocating memory for MSG_CHCOS") ;
136                        return 0 ;
137                    }
138                    if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
139                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_CHCOS") ;
140                        FREE(receive_buffer) ;
141                        return -1 ;
142                    }
143                    msg_integer = (struct  mess_integer *) receive_buffer ;
144#ifndef WORDS_BIGENDIAN
145                    mycos = ntohl(msg_integer->myint) ;
146#else
147                    mycos = msg_integer->myint ;
148#endif
149                    if (mycos>=0) {
150                        bbftpd_log(BBFTPD_DEBUG,"Cos set to %d",mycos) ;
151                        reply(MSG_OK,"COS set") ;
152                    } else {
153                        bbftpd_log(BBFTPD_DEBUG,"Cos received : %d",mycos) ;
154                        reply(MSG_OK,"COS not set") ;
155                    }
156                    FREE(receive_buffer) ;
157                    return 0 ;
158               }
159
160                case MSG_CHDIR_V2 : {
161                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CHDIR_V2, msglen = %d",msglen) ;
162                    retcode = bbftpd_cd(incontrolsock,msglen) ;
163                    return retcode ;
164                }
165               
166                case MSG_CHUMASK : {
167                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_UMASK ") ;
168                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
169                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_UMASK : %s",strerror(errno)) ;
170                        reply(MSG_BAD,"Error allocating memory for MSG_UMASK") ;
171                        return 0 ;
172                    }
173                    if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
174                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_UMASK") ;
175                        FREE(receive_buffer) ;
176                        return -1 ;
177                    }
178                    msg_integer = (struct  mess_integer *) receive_buffer ;
179#ifndef WORDS_BIGENDIAN
180                    myumask = ntohl(msg_integer->myint) ;
181#else
182                    myumask = msg_integer->myint ;
183#endif
184                    /*
185                    ** We reset the umask first then call twice the umask
186                    ** in order to see the real umask set
187                    */
188                    oldumask = umask(0) ;
189                    umask(myumask) ;
190                    newumask = umask(myumask) ;
191                    sprintf(logmessage,"umask changed from %04o to %04o",oldumask,newumask) ;
192                    reply(MSG_OK,logmessage) ;
193                    FREE(receive_buffer) ;
194                    return 0 ;
195                }
196 
197                case MSG_CLOSE_CONN : {
198                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CLOSE_CONN, msglen = %d",msglen) ;
199                    return -1 ;
200                }
201               
202               
203                case MSG_LIST_V2 :{
204                   bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_LIST_V2 ") ;
205                   if ( (receive_buffer = (char *) malloc (msglen+1) ) == NULL ) {
206                        bbftpd_log(BBFTPD_ERR,"Unable to malloc space for directory name (%d)",msglen) ;
207                        reply(MSG_BAD,"Unable to malloc space for directory name") ;
208                       return 0 ;
209                   }
210                  /*
211                   ** Read the characteristics of the directory
212                   */
213                   if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
214                       /*
215                       ** Error ...
216                       */
217                        bbftpd_log(BBFTPD_ERR,"Error reading directory name") ;
218                       FREE(receive_buffer) ;
219                       return -1 ;
220                   }
221                   /*
222                   ** buffer contains the directory to create
223                   */
224                   receive_buffer[msglen] = '\0' ;
225                   msg_dir = (struct mess_dir *) receive_buffer ;
226#ifdef NDG_AUTH
227                    if (bbftpd_private_authz_control(msgcode, msg_dir->transferoption, msg_dir->dirname,
228                                                     logmessage) != 0) {
229                      bbftpd_log(BBFTPD_ERR, logmessage);
230                      reply(MSG_BAD, logmessage);
231                      FREE(receive_buffer);
232                      return 0;
233                    }
234#endif // NDG_AUTH
235                   transferoption  = msg_dir->transferoption ;
236                   bbftpd_log(BBFTPD_DEBUG,"Pattern = %s",msg_dir->dirname) ;
237                   retcode = bbftpd_list(msg_dir->dirname,logmessage) ;
238                   FREE(receive_buffer) ;
239                   return retcode ;
240                }
241               
242                case MSG_MKDIR_V2 : {
243                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_MKDIR_V2 ") ;
244                    retcode = bbftpd_mkdir(incontrolsock,msglen) ;
245                    return retcode ;
246                }
247               
248                case MSG_RM : {
249                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_RM ") ;
250                    retcode = bbftpd_rm(incontrolsock,msglen) ;
251                    return retcode ;
252                }
253               
254                case MSG_STAT : {
255                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_STAT ") ;
256                    retcode = bbftpd_stat(incontrolsock,msglen) ;
257                    return retcode ;
258                }
259                   
260                case MSG_DF : {
261                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_DF ") ;
262                    retcode = bbftpd_statfs(incontrolsock,msglen) ;
263                    return retcode ;
264                }
265                   
266                case MSG_RETR_V2 : {
267                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_RETR_V2") ;
268                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
269                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_RETR_V2 : %s",strerror(errno)) ;
270                        return -1 ;
271                    }
272                     if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
273                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_RETR_V2") ;
274                        FREE(receive_buffer) ;
275                        return -1 ;
276                    }
277                    msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
278
279                    /*
280                    ** Set up the transfer parameter, we are going only to store
281                    ** them
282                    */
283#ifndef WORDS_BIGENDIAN
284                    transferoption          = msg_store_v2->transferoption ;
285                    sendwinsize             = ntohl(msg_store_v2->sendwinsize) ;
286                    recvwinsize             = ntohl(msg_store_v2->recvwinsize) ;
287                    buffersizeperstream     = ntohl(msg_store_v2->buffersizeperstream) ;
288                    requestedstreamnumber   = ntohl(msg_store_v2->nbstream) ;
289#else
290                    transferoption          = msg_store_v2->transferoption ;
291                    sendwinsize             = msg_store_v2->sendwinsize ;
292                    recvwinsize             = msg_store_v2->recvwinsize ;
293                    buffersizeperstream     = msg_store_v2->buffersizeperstream ;
294                    requestedstreamnumber   = msg_store_v2->nbstream ;
295#endif
296                    bbftpd_log(BBFTPD_DEBUG,"transferoption         = %d ",transferoption) ;
297                    bbftpd_log(BBFTPD_DEBUG,"sendwinsize            = %d ",sendwinsize) ;
298                    bbftpd_log(BBFTPD_DEBUG,"recvwinsize            = %d ",recvwinsize) ;
299                    bbftpd_log(BBFTPD_DEBUG,"buffersizeperstream    = %d ",buffersizeperstream) ;
300                    bbftpd_log(BBFTPD_DEBUG,"requestedstreamnumber  = %d ",requestedstreamnumber) ;
301                    state = S_WAITING_FILENAME_RETR ;
302                    FREE(receive_buffer) ;
303                    return 0 ;
304                }
305               
306                case MSG_STORE_V2 :{
307                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_STORE_V2") ;
308                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
309                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_STORE_V2 : %s",strerror(errno)) ;
310                        return -1 ;
311                    }
312                     if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
313                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_STORE_V2") ;
314                        FREE(receive_buffer) ;
315                        return -1 ;
316                    }
317                    msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
318
319                    /*
320                    ** Set up the transfer parameter, we are going only to store
321                    ** them
322                    */
323#ifndef WORDS_BIGENDIAN
324                    transferoption          = msg_store_v2->transferoption ;
325                    filemode                = ntohl(msg_store_v2->filemode) ;
326                    strncpy(lastaccess,msg_store_v2->lastaccess,8) ;
327                    lastaccess[8] = '\0' ;
328                    strncpy(lastmodif,msg_store_v2->lastmodif,8) ;
329                    lastmodif[8] = '\0' ;
330                    sendwinsize             = ntohl(msg_store_v2->sendwinsize) ;
331                    recvwinsize             = ntohl(msg_store_v2->recvwinsize) ;
332                    buffersizeperstream     = ntohl(msg_store_v2->buffersizeperstream) ;
333                    requestedstreamnumber   = ntohl(msg_store_v2->nbstream) ;
334                    filesize                = ntohll(msg_store_v2->filesize) ;
335#else
336                    transferoption          = msg_store_v2->transferoption ;
337                    filemode                = msg_store_v2->filemode ;
338                    strncpy(lastaccess,msg_store_v2->lastaccess,8) ;
339                    lastaccess[8] = '\0' ;
340                    strncpy(lastmodif,msg_store_v2->lastmodif,8) ;
341                    lastmodif[8] = '\0' ;
342                    sendwinsize             = msg_store_v2->sendwinsize ;
343                    recvwinsize             = msg_store_v2->recvwinsize ;
344                    buffersizeperstream     = msg_store_v2->buffersizeperstream ;
345                    requestedstreamnumber   = msg_store_v2->nbstream ;
346                    filesize                = msg_store_v2->filesize ;
347#endif
348                    bbftpd_log(BBFTPD_DEBUG,"transferoption         = %d ",transferoption) ;
349                    bbftpd_log(BBFTPD_DEBUG,"filemode               = %d ",filemode) ;
350                    bbftpd_log(BBFTPD_DEBUG,"lastaccess             = %s ",lastaccess) ;
351                    bbftpd_log(BBFTPD_DEBUG,"lastmodif              = %s ",lastmodif) ;
352                    bbftpd_log(BBFTPD_DEBUG,"sendwinsize            = %d ",sendwinsize) ;
353                    bbftpd_log(BBFTPD_DEBUG,"recvwinsize            = %d ",recvwinsize) ;
354                    bbftpd_log(BBFTPD_DEBUG,"buffersizeperstream    = %d ",buffersizeperstream) ;
355                    bbftpd_log(BBFTPD_DEBUG,"requestedstreamnumber  = %d ",requestedstreamnumber) ;
356                    bbftpd_log(BBFTPD_DEBUG,"filesize               = %" LONG_LONG_FORMAT " ",filesize) ;
357                    state = S_WAITING_FILENAME_STORE ;
358                    FREE(receive_buffer) ;
359                    return 0 ;
360                }
361               
362                default :{
363                    bbftpd_log(BBFTPD_ERR,"Unkown message in logged state %d",msgcode) ;
364                    retcode = discardmessage(incontrolsock,msglen,recvcontrolto) ;
365                    reply(MSG_BAD_NO_RETRY,"Unkown message in S_LOGGED state") ;
366                    return retcode ;
367                }
368            }
369        }
370        /*
371        ** Case S_WAITING_FILENAME_STORE
372        **
373        **         MSG_FILENAME
374        */
375           case S_WAITING_FILENAME_STORE : {
376            switch (msgcode) {
377                case MSG_FILENAME :{
378                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_FILENAME in S_WAITING_FILENAME_STORE state") ;
379                    if ( msglen == 0 ) {
380                         bbftpd_log(BBFTPD_ERR,"Filename length null") ;
381                         return -1 ;
382                    }
383                    if ( (curfilename = (char *) malloc (msglen+1)) == NULL ) {
384                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for filename : %s",strerror(errno)) ;
385                        return -1 ;
386                    }
387                    /* tmp name = <name>.bbftp.tmp.<hostname in 10 chars>.<pid in 5 chars> */
388                    if ( (realfilename = (char *) malloc (msglen+30)) == NULL ) {
389                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for realfilename : %s",strerror(errno)) ;
390                        free_all_var() ;
391                        return -1 ;
392                    }
393                    if ( readmessage(incontrolsock,curfilename,msglen,recvcontrolto) < 0 ) {
394                        bbftpd_log(BBFTPD_ERR,"Error reading filename") ;
395                        free_all_var() ;
396                        return -1 ;
397                    }
398                    curfilename[msglen] = '\0' ;
399                    curfilenamelen = msglen ;
400                    bbftpd_log(BBFTPD_DEBUG,"Request to store file %s",curfilename) ;
401#ifdef NDG_AUTH
402                    if (bbftpd_private_authz_store(curfilename, logmessage) != 0) {
403                      bbftpd_log(BBFTPD_ERR, logmessage);
404                      reply(MSG_BAD_NO_RETRY, logmessage);
405                      free_all_var();
406                      state = S_LOGGED;
407                      return 0;
408                    }
409#endif // NDG_AUTH
410                    if ( (retcode = bbftpd_storecheckoptions(logmessage)) < 0 ) {
411                        bbftpd_log(BBFTPD_ERR,logmessage) ;
412                        reply(MSG_BAD_NO_RETRY,logmessage) ;
413                        free_all_var() ;
414                        state = S_LOGGED ;
415                        return 0 ;
416                    }
417                    /*
418                    ** Options are corrects
419                    */
420                    if ( (transferoption & TROPT_TMP ) == TROPT_TMP ) {
421                        /*
422                        ** Caculate tempfile name if TROPT_TMP is set
423                        ** To avoid multiple access to temp file in HPSS
424                        ** file is called .bbftp.tmp.$host.$pid
425                        */
426                        char hostname[10 + 1];
427                        if (gethostname(hostname, sizeof(hostname)) < 0) {
428                                sprintf(realfilename,"%s.bbftp.tmp.%d",curfilename,getpid());
429                        } else {
430                                hostname[sizeof(hostname) - 1] = '\0';
431                                sprintf(realfilename,"%s.bbftp.tmp.%s.%d",curfilename,hostname,getpid()) ;
432                        }
433                    } else {
434                        sprintf(realfilename,"%s",curfilename) ;
435                    }
436                    /*
437                    ** Create the file
438                    */
439                    if ( (retcode = bbftpd_storecreatefile(realfilename,logmessage)) < 0 ) {
440                        bbftpd_log(BBFTPD_ERR,logmessage) ;
441                        reply(MSG_BAD_NO_RETRY,logmessage) ;
442                        free_all_var() ;
443                        state = S_LOGGED ;
444                        return 0 ;
445                    } else if ( retcode > 0 ) {
446                        bbftpd_log(BBFTPD_ERR,logmessage) ;
447                        reply(MSG_BAD,logmessage) ;
448                        free_all_var() ;
449                        state = S_LOGGED ;
450                        return 0 ;
451                    } else {
452                        if ( filesize == 0 ) {
453                            if ((transferoption & TROPT_ACC ) == TROPT_ACC ) {
454                                sscanf(lastaccess,"%08x",&ftime.actime) ;
455                                sscanf(lastmodif,"%08x",&ftime.modtime) ;
456                                if ( bbftpd_storeutime(realfilename,&ftime,logmessage) < 0 ) {
457                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
458                                    bbftpd_storeunlink(realfilename) ;
459                                    reply(MSG_BAD,logmessage) ;
460                                    free_all_var() ;
461                                    state = S_LOGGED ;
462                                    return 0 ;
463                                }
464                           }
465                           if ( (transferoption & TROPT_MODE ) == TROPT_MODE ) {
466                                if ( bbftpd_storechmod(realfilename,filemode,logmessage) < 0 ) {
467                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
468                                    bbftpd_storeunlink(realfilename) ;
469                                    reply(MSG_BAD,logmessage) ;
470                                    free_all_var() ;
471                                    state = S_LOGGED ;
472                                    return 0 ;
473                                }
474                            }
475                            if ( (transferoption & TROPT_TMP ) == TROPT_TMP ) {
476                                if ( bbftpd_storerename(realfilename,curfilename,logmessage) < 0 ) {
477                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
478                                    bbftpd_storeunlink(realfilename) ;
479                                    reply(MSG_BAD,logmessage) ;
480                                    free_all_var() ;
481                                    state = S_LOGGED ;
482                                    return 0 ;
483                                }
484                            }
485                            reply(MSG_OK,"") ;
486                            free_all_var() ;
487                            state = S_LOGGED ;
488                            return 0 ;
489                        } else {
490                            /*
491                            ** We are reserving the memory for the ports
492                            */
493                            if ( (myports = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
494                                bbftpd_storeunlink(realfilename) ;
495                                free_all_var() ;
496                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for myports") ;
497                                sprintf(logmessage,"Unable to allocate memory for myports") ;
498                                reply(MSG_BAD,logmessage) ;
499                                state = S_LOGGED ;
500                                return 0 ;
501                            }
502                            /*
503                            ** We are reserving the memory for the children pid
504                            */
505                            if ( (mychildren = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL) {
506                                bbftpd_storeunlink(realfilename) ;
507                                free_all_var() ;
508                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for mychildren") ;
509                                sprintf(logmessage,"Unable to allocate memory for mychildren") ;
510                                reply(MSG_BAD,logmessage) ;
511                                state = S_LOGGED ;
512                                return 0 ;
513                            }
514                            /*
515                            ** We are reserving the memory for the readbuffer
516                            */
517                            if ( (readbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
518                                bbftpd_storeunlink(realfilename) ;
519                                free_all_var() ;
520                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for readbuffer") ;
521                                sprintf(logmessage,"Unable to allocate memory for readbuffer") ;
522                                reply(MSG_BAD,logmessage) ;
523                                state = S_LOGGED ;
524                                return 0 ;
525                            }
526                            /*
527                            ** We are reserving the memory for the compression buffer
528                            ** if needed
529                            */
530                            if ( (transferoption & TROPT_GZIP ) == TROPT_GZIP ) {
531                                if ( (compbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
532                                    bbftpd_storeunlink(realfilename) ;
533                                    free_all_var() ;
534                                    bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for compbuffer") ;
535                                    sprintf(logmessage,"Unable to allocate memory for compbuffer") ;
536                                    reply(MSG_BAD,logmessage) ;
537                                    state = S_LOGGED ;
538                                    return 0 ;
539                                }
540                            }
541                            if ( (receive_buffer = (char *) malloc (STORMESSLEN_V2)) == NULL ) {
542                                bbftpd_storeunlink(realfilename) ;
543                                bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_TRANS_OK_V2 : %s",strerror(errno)) ;
544                                free_all_var() ;
545                                sprintf(logmessage,"Unable to allocate memory for message MSG_TRANS_OK_V2") ;
546                                reply(MSG_BAD,logmessage) ;
547                                state = S_LOGGED ;
548                                return 0 ;
549                            }
550                            msg = (struct message *) receive_buffer ;
551                            if ( protocolversion == 2) { /* ACTIVE MODE */
552                              msg->code = MSG_TRANS_OK_V2 ;
553                            } else { /* PASSIVE MODE */
554                              msg->code = MSG_TRANS_OK_V3 ;
555                            }
556#ifndef WORDS_BIGENDIAN
557                            msg->msglen = ntohl(STORMESSLEN_V2) ;
558#else
559                            msg->msglen = STORMESSLEN_V2 ;
560#endif
561                            if ( writemessage(outcontrolsock,receive_buffer,MINMESSLEN,sendcontrolto) < 0 ) {
562                                bbftpd_log(BBFTPD_ERR,"Error wtiting MSG_TRANS_OK_V2 first part") ;
563                                bbftpd_storeunlink(realfilename) ;
564                                free_all_var() ;
565                                FREE(receive_buffer) ;
566                                return -1 ;
567                            }
568                            msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
569                            /*
570                            ** Set up the transfer parameter
571                            */
572#ifndef WORDS_BIGENDIAN
573                            msg_store_v2->transferoption       = transferoption ;
574                            msg_store_v2->filemode             = ntohl(filemode) ;
575                            strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
576                            msg_store_v2->lastaccess[8] = '0' ;
577                            strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
578                            msg_store_v2->lastmodif[8] = '0' ;
579                            msg_store_v2->sendwinsize          = ntohl(sendwinsize) ;
580                            msg_store_v2->recvwinsize          = ntohl(recvwinsize) ;
581                            msg_store_v2->buffersizeperstream  = ntohl(buffersizeperstream) ;
582                            msg_store_v2->nbstream             = ntohl(requestedstreamnumber) ;
583                            msg_store_v2->filesize             = ntohll(filesize) ;
584#else
585                            msg_store_v2->transferoption       = transferoption  ;       
586                            msg_store_v2->filemode             =  filemode;
587                            strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
588                            msg_store_v2->lastaccess[8] = '0' ;
589                            strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
590                            msg_store_v2->lastmodif[8] = '0' ;
591                            msg_store_v2->sendwinsize          = sendwinsize ;
592                            msg_store_v2->recvwinsize          = recvwinsize ;
593                            msg_store_v2->buffersizeperstream  = buffersizeperstream ;
594                            msg_store_v2->nbstream             = requestedstreamnumber;
595                            msg_store_v2->filesize             = filesize ;
596#endif
597                            if ( writemessage(outcontrolsock,receive_buffer,STORMESSLEN_V2,sendcontrolto) < 0 ) {
598                                bbftpd_log(BBFTPD_ERR,"Error wtiting MSG_TRANS_OK_V2 second part") ;
599                                bbftpd_storeunlink(realfilename) ;
600                                free_all_var() ;
601                                FREE(receive_buffer) ;
602                                return -1 ;
603                            }
604                            /* PASSIVE MODE: send ports */
605                            if ( protocolversion >= 3 ) {
606                              /*
607                              ** We are reserving the memory for the ports
608                              */
609                              if ( (mysockets = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
610                                bbftpd_log(BBFTPD_ERR,"Error allocating space for sockets") ;
611                                bbftpd_storeunlink(realfilename) ;
612                                free_all_var() ;
613                                FREE(receive_buffer) ;
614                                return -1 ;
615                              }
616                              if ( bbftpd_getdatasock(requestedstreamnumber) < 0 ) {
617                                bbftpd_log(BBFTPD_ERR,"Error creating data sockets") ;
618                                bbftpd_storeunlink(realfilename) ;
619                                free_all_var() ;
620                                FREE(receive_buffer) ;
621                                return -1 ;
622                              }
623                              portfree = (int *)receive_buffer ;
624                              porttosend = myports ;
625                              for (i=0 ; i<requestedstreamnumber  ; i++) {
626#ifndef WORDS_BIGENDIAN
627                                *portfree++  = ntohl(ntohs(*porttosend++)) ;
628#else
629                                *portfree++ = *porttosend++ ;
630#endif
631                              }
632/*          bbftpd_log(BBFTPD_INFO,"Port=%d,socket=%d\n",*myports,*mysockets) ;*/
633                              if ( writemessage(outcontrolsock,receive_buffer,requestedstreamnumber*sizeof(int),sendcontrolto) < 0) {
634                                bbftpd_log(BBFTPD_ERR,"Error writing MSG_TRANS_OK_V3 (ports)") ;
635                                bbftpd_storeunlink(realfilename) ;
636                                free_all_var() ;
637                                FREE(receive_buffer) ;
638                                return -1 ;
639                              }
640                            } /* END PASSIVE MODE */
641                            state = S_WAITING_STORE_START ;
642                            FREE(receive_buffer) ;
643                            return 0 ;
644                        }
645                    }
646                }
647                default :{
648                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_FILENAME_STORE state : %d",msgcode) ;
649                    return -1 ;
650                }
651            }
652        }
653        /*
654        ** Case S_WAITING_FILENAME_RETR
655        **
656        **         MSG_FILENAME
657        */
658           case S_WAITING_FILENAME_RETR : {
659            switch (msgcode) {
660                case MSG_FILENAME :{
661                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_FILENAME in S_WAITING_FILENAME_RETR state") ;
662                    if ( msglen == 0 ) {
663                         bbftpd_log(BBFTPD_ERR,"Filename length null") ;
664                         return -1 ;
665                    }
666                    if ( (curfilename = (char *) malloc (msglen+1)) == NULL ) {
667                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for filename : %s",strerror(errno)) ;
668                        return -1 ;
669                    }
670                    if ( readmessage(incontrolsock,curfilename,msglen,recvcontrolto) < 0 ) {
671                        bbftpd_log(BBFTPD_ERR,"Error reading filename") ;
672                        free_all_var() ;
673                        return -1 ;
674                    }
675                    curfilename[msglen] = '\0' ;
676                    curfilenamelen = msglen ;
677                    bbftpd_log(BBFTPD_DEBUG,"Request to retreive file %s",curfilename) ;
678#ifdef NDG_AUTH
679                    if (bbftpd_private_authz_retr(curfilename, logmessage) != 0) {
680                      bbftpd_log(BBFTPD_ERR, logmessage);
681                      reply(MSG_BAD_NO_RETRY, logmessage);
682                      free_all_var();
683                      state = S_LOGGED;
684                      return 0;
685                    }
686#endif // NDG_AUTH
687                    /*
688                    ** Create the file
689                    */
690                    if ( (retcode = bbftpd_retrcheckfile(curfilename,logmessage)) < 0 ) {
691                        bbftpd_log(BBFTPD_ERR,logmessage) ;
692                        reply(MSG_BAD_NO_RETRY,logmessage) ;
693                        free_all_var() ;
694                        state = S_LOGGED ;
695                        return 0 ;
696                    } else if ( retcode > 0 ) {
697                        bbftpd_log(BBFTPD_ERR,logmessage) ;
698                        reply(MSG_BAD,logmessage) ;
699                        free_all_var() ;
700                        state = S_LOGGED ;
701                        return 0 ;
702                    } else {
703                        if ( filesize != 0 ) {
704                            /*
705                            ** We are reserving the memory for the ports
706                            */
707                            if ( (myports = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
708                                free_all_var() ;
709                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for myports") ;
710                                sprintf(logmessage,"Unable to allocate memory for myports") ;
711                                reply(MSG_BAD,logmessage) ;
712                                state = S_LOGGED ;
713                                return 0 ;
714                            }
715                            /*
716                            ** We are reserving the memory for the children pid
717                            */
718                            if ( (mychildren = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL) {
719                                free_all_var() ;
720                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for mychildren") ;
721                                sprintf(logmessage,"Unable to allocate memory for mychildren") ;
722                                reply(MSG_BAD,logmessage) ;
723                                state = S_LOGGED ;
724                                return 0 ;
725                            }
726                            /*
727                            ** We are reserving the memory for the readbuffer
728                            */
729                            if ( (readbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
730                                free_all_var() ;
731                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for readbuffer") ;
732                                sprintf(logmessage,"Unable to allocate memory for readbuffer") ;
733                                reply(MSG_BAD,logmessage) ;
734                                state = S_LOGGED ;
735                                return 0 ;
736                            }
737                            /*
738                            ** We are reserving the memory for the compression buffer
739                            ** if needed
740                            */
741                            if ( (transferoption & TROPT_GZIP ) == TROPT_GZIP ) {
742#ifdef WITH_GZIP
743                                if ( (compbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
744                                    free_all_var() ;
745                                    bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for compbuffer") ;
746                                    sprintf(logmessage,"Unable to allocate memory for compbuffer") ;
747                                    reply(MSG_BAD,logmessage) ;
748                                    state = S_LOGGED ;
749                                    return 0 ;
750                                }
751#else
752                                transferoption = transferoption & ~TROPT_GZIP ;
753#endif
754                            }
755                        }
756                        if ( (receive_buffer = (char *) malloc (STORMESSLEN_V2)) == NULL ) {
757                            bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_TRANS_OK_V2 : %s",strerror(errno)) ;
758                            free_all_var() ;
759                            sprintf(logmessage,"Unable to allocate memory for message MSG_TRANS_OK_V2") ;
760                            reply(MSG_BAD,logmessage) ;
761                            state = S_LOGGED ;
762                            return 0 ;
763                          }
764                        msg = (struct message *) receive_buffer ;
765                        if ( protocolversion == 2) { /* ACTIVE MODE */
766                          msg->code = MSG_TRANS_OK_V2 ;
767                        } else { /* PASSIVE MODE */
768                          msg->code = MSG_TRANS_OK_V3 ;
769                        }
770#ifndef WORDS_BIGENDIAN
771                        msg->msglen = ntohl(STORMESSLEN_V2) ;
772#else
773                        msg->msglen = STORMESSLEN_V2 ;
774#endif
775                        if ( writemessage(outcontrolsock,receive_buffer,MINMESSLEN,sendcontrolto) < 0 ) {
776                            bbftpd_log(BBFTPD_ERR,"Error writing MSG_TRANS_OK_V2 first part") ;
777                            free_all_var() ;
778                            FREE(receive_buffer) ;
779                            return -1 ;
780                        }
781                        msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
782                        /*
783                        ** Set up the transfer parameter
784                        */
785#ifndef WORDS_BIGENDIAN
786                        msg_store_v2->transferoption       = transferoption ;
787                        msg_store_v2->filemode             = ntohl(filemode) ;
788                        strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
789                        msg_store_v2->lastaccess[8] = '0' ;
790                        strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
791                        msg_store_v2->lastmodif[8] = '0' ;
792                        msg_store_v2->sendwinsize          = ntohl(sendwinsize) ;
793                        msg_store_v2->recvwinsize          = ntohl(recvwinsize) ;
794                        msg_store_v2->buffersizeperstream  = ntohl(buffersizeperstream) ;
795                        msg_store_v2->nbstream             = ntohl(requestedstreamnumber) ;
796                        msg_store_v2->filesize             = ntohll(filesize) ;
797#else
798                        msg_store_v2->transferoption       = transferoption  ;       
799                        msg_store_v2->filemode             =  filemode;
800                        strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
801                        msg_store_v2->lastaccess[8] = '0' ;
802                        strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
803                        msg_store_v2->lastmodif[8] = '0' ;
804                        msg_store_v2->sendwinsize          = sendwinsize ;
805                        msg_store_v2->recvwinsize          = recvwinsize ;
806                        msg_store_v2->buffersizeperstream  = buffersizeperstream ;
807                        msg_store_v2->nbstream             = requestedstreamnumber;
808                        msg_store_v2->filesize             = filesize ;
809#endif
810                        if ( writemessage(outcontrolsock,receive_buffer,STORMESSLEN_V2,sendcontrolto) < 0 ) {
811                            bbftpd_log(BBFTPD_ERR,"Error writing MSG_TRANS_OK_V2 second part") ;
812                            bbftpd_storeunlink(realfilename) ;
813                            free_all_var() ;
814                            FREE(receive_buffer) ;
815                            return -1 ;
816                        }
817                        if ( filesize == 0 ) {
818                            char statmessage[1024];
819                            state = S_WAITING_CREATE_ZERO ;
820                            sprintf(statmessage,"GET %s %s 0 0 0.0 0.0", currentusername, curfilename);
821                            bbftpd_log(BBFTPD_NOTICE,statmessage);
822                            free_all_var() ;
823                        } else {
824                            /* PASSIVE MODE: send ports */
825                            if ( protocolversion >= 3 ) {
826                              /*
827                              ** We are reserving the memory for the ports
828                              */
829                              if ( (mysockets = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
830                                bbftpd_log(BBFTPD_ERR,"Error allocating space for sockets") ;
831                                bbftpd_storeunlink(realfilename) ;
832                                free_all_var() ;
833                                FREE(receive_buffer) ;
834                                return -1 ;
835                              }
836                              if ( bbftpd_getdatasock(requestedstreamnumber) < 0 ) {
837                                bbftpd_log(BBFTPD_ERR,"Error creating data sockets") ;
838                                bbftpd_storeunlink(realfilename) ;
839                                free_all_var() ;
840                                FREE(receive_buffer) ;
841                                return -1 ;
842                              }
843                              portfree = (int *)receive_buffer ;
844                              porttosend = myports ;
845                              for (i=0 ; i<requestedstreamnumber  ; i++) {
846#ifndef WORDS_BIGENDIAN
847                                *portfree++  = ntohl(ntohs(*porttosend++)) ;
848#else
849                                *portfree++ = *porttosend++ ;
850#endif
851                              }
852/*          bbftpd_log(BBFTPD_INFO,"Port=%d,socket=%d\n",*myports,*mysockets) ;*/
853                              if ( writemessage(outcontrolsock,receive_buffer,requestedstreamnumber*sizeof(int),sendcontrolto) < 0) {
854                                bbftpd_log(BBFTPD_ERR,"Error writing MSG_TRANS_OK_V3 (ports)") ;
855                                bbftpd_storeunlink(realfilename) ;
856                                free_all_var() ;
857                                FREE(receive_buffer) ;
858                                return -1 ;
859                              }
860                            } /* END PASSIVE MODE */
861                            state = S_WAITING_RETR_START ;
862                        }
863                        FREE(receive_buffer) ;
864                        return 0 ;
865                    }
866                }
867                default :{
868                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_FILENAME state : %d",msgcode) ;
869                    return -1 ;
870                }
871            }
872        }
873       
874        /*
875        ** Case S_WAITING_STORE_START
876        **
877        **         MSG_TRANS_START_V2
878        **         MSG_TRANS_SIMUL
879        **         MSG_ABORT
880        */
881        case S_WAITING_STORE_START : {
882             switch (msgcode) {
883                case MSG_TRANS_START_V2 :
884                case MSG_TRANS_SIMUL :
885                case MSG_TRANS_START_V3 :
886                case MSG_TRANS_SIMUL_V3 :{
887                    int simulation = ((msgcode == MSG_TRANS_SIMUL) || (msgcode == MSG_TRANS_SIMUL_V3)?1:0);
888                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_TRANS_START_V2") ;
889                    if ( msglen != requestedstreamnumber*sizeof(int)) {
890                        bbftpd_storeunlink(realfilename) ;
891                        free_all_var() ;
892                        reply(MSG_BAD,"Inconsistency between MSG_TRANS_START_V2 and message length") ;
893                        bbftpd_log(BBFTPD_ERR,"Inconsistency between MSG_TRANS_START_V2 and message length") ;
894                        return -1 ;
895                    }
896                    if (msgcode == MSG_TRANS_START_V2 || msgcode == MSG_TRANS_SIMUL) { /* ACTIVE MODE */
897                      /*
898                      ** Retreive port numbers
899                      */
900                      if ( readmessage(incontrolsock,(char *) myports,msglen,recvcontrolto) < 0 ) {
901                        bbftpd_storeunlink(realfilename) ;
902                        free_all_var() ;
903                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_TRANS_START_V2") ;
904                        return -1 ;
905                      } else {
906#ifndef WORDS_BIGENDIAN
907                        portfree = myports ;
908                        for (i=0 ; i < requestedstreamnumber ; i++ ) {
909                            *portfree = ntohl(*portfree) ;
910                            portfree++ ;
911                        }
912#endif
913                        portfree = myports ;
914                        for (i=0 ; i < requestedstreamnumber ; i++ ) {
915                            portfree++ ;
916                        }
917                      }
918                    }
919                    if ( (retcode = bbftpd_storetransferfile(realfilename,simulation,logmessage)) == 0 ) {
920                        /*
921                        ** Everything seems to work correctly
922                        */
923                        return 0 ;
924                    }
925                    if ( retcode > 0 ) {
926                        /*
927                        ** Something goes wrong
928                        */
929                        bbftpd_storeunlink(realfilename) ;
930                        free_all_var() ;
931                        state = S_LOGGED ;
932                        return 0 ;
933                    }
934                    /*
935                    **
936                    */
937                    bbftpd_storeunlink(realfilename) ;
938                    free_all_var() ;
939                    state = S_LOGGED ;
940                    return -1 ;
941                }
942                case MSG_ABORT : {
943                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
944                    bbftpd_storeunlink(realfilename) ;
945                    free_all_var() ;
946                    state = S_LOGGED ;
947                    return 0 ;
948                }
949                default :{
950                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_STORE_START state : %d",msgcode) ;
951                    bbftpd_storeunlink(realfilename) ;
952                    free_all_var() ;
953                    return -1 ;
954                }
955            }
956        }
957        /*
958        ** Case S_WAITING_CREATE_ZERO
959        **
960        **         MSG_CREATE_ZERO
961        **         MSG_ABORT
962        */
963        case S_WAITING_CREATE_ZERO : {
964             switch (msgcode) {
965                case MSG_CREATE_ZERO : {
966                    bbftpd_log(BBFTPD_ERR,"Receive MSG_CREATE_ZERO message ") ;
967                    state = S_LOGGED ;
968                    return 0 ;
969                }
970                case MSG_ABORT : {
971                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
972                    state = S_LOGGED ;
973                    return 0 ;
974                }
975                default :{
976                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_CREATE_ZERO state : %d",msgcode) ;
977                    return -1 ;
978                }
979            }
980        }
981        /*
982        ** Case S_WAITING_RETR_START
983        **
984        **         MSG_TRANS_START_V2
985        **         MSG_TRANS_SIMUL
986        **         MSG_ABORT
987        */
988        case S_WAITING_RETR_START : {
989             switch (msgcode) {
990                case MSG_TRANS_START_V2 :
991                case MSG_TRANS_SIMUL :
992                case MSG_TRANS_START_V3 :
993                case MSG_TRANS_SIMUL_V3 :{
994                    int simulation = ((msgcode == MSG_TRANS_SIMUL) || (msgcode == MSG_TRANS_SIMUL_V3)?1:0);
995                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_TRANS_START_V2") ;
996                    if ( msglen != requestedstreamnumber*sizeof(int)) {
997                        free_all_var() ;
998                        reply(MSG_BAD,"Inconsistency between MSG_TRANS_START_V2 and message length") ;
999                        bbftpd_log(BBFTPD_ERR,"Inconsistency between MSG_TRANS_START_V2 and message length") ;
1000                        return -1 ;
1001                    }
1002                    if (msgcode == MSG_TRANS_START_V2 || msgcode == MSG_TRANS_SIMUL) { /* ACTIVE MODE */
1003                      /*
1004                      ** Retreive port numbers
1005                      */
1006                      if ( readmessage(incontrolsock,(char *) myports,msglen,recvcontrolto) < 0 ) {
1007                        free_all_var() ;
1008                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_TRANS_START_V2") ;
1009                        return -1 ;
1010                      } else {
1011#ifndef WORDS_BIGENDIAN
1012                        portfree = myports ;
1013                        for (i=0 ; i < requestedstreamnumber ; i++ ) {
1014                            *portfree = ntohl(*portfree) ;
1015                            portfree++ ;
1016                        }
1017#endif
1018                        /*portfree = myports ;
1019                        for (i=0 ; i < requestedstreamnumber ; i++ ) {
1020                            portfree++ ;
1021                                                        }*/
1022                      }
1023                    }
1024                    if ( (retcode = bbftpd_retrtransferfile(curfilename,simulation,logmessage)) == 0 ) {
1025                        /*
1026                        ** Everything seems to work correctly
1027                        */                       
1028                        return 0 ;
1029                    }
1030                    if ( retcode > 0 ) {
1031                        /*
1032                        ** Something goes wrong
1033                        */
1034                        bbftpd_log(BBFTPD_ERR,"retrtransferfile retcode > 0") ;
1035                        free_all_var() ;
1036                        state = S_LOGGED ;
1037                        return 0 ;
1038                    }
1039                    /*
1040                    **
1041                    */
1042                    bbftpd_log(BBFTPD_ERR,"retrtransferfile retcode < 0") ;
1043                    free_all_var() ;
1044                    state = S_LOGGED ;
1045                    return -1 ;
1046                }
1047                case MSG_ABORT : {
1048                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
1049                    free_all_var() ;
1050                    state = S_LOGGED ;
1051                    return 0 ;
1052                }
1053                default :{
1054                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_RETR_START state : %d",msgcode) ;
1055                    return -1 ;
1056                }
1057            }
1058        }
1059        /*
1060        ** Case S_SENDING or S_RECEIVING
1061        */
1062        case S_SENDING : {
1063              switch (msgcode) {
1064                case MSG_ABORT :{
1065                    bbftpd_log(BBFTPD_ERR,"Receive MSG_ABORT while sending") ;
1066                    return -1 ;
1067                }
1068                default :{
1069                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_SENDING state: %d",msgcode) ;
1070                    return -1 ;
1071                }   
1072            }
1073        }
1074        case S_RECEIVING : {
1075              switch (msgcode) {
1076                case MSG_ABORT :{
1077                    bbftpd_log(BBFTPD_ERR,"Receive MSG_ABORT while receiving") ;
1078                    bbftpd_storeclosecastfile(realfilename,logmessage) ;
1079                    bbftpd_storeunlink(realfilename) ;
1080                    return -1 ;
1081                }
1082                default :{
1083                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_RECEIVING state : %d",msgcode) ;
1084                    bbftpd_storeclosecastfile(realfilename,logmessage) ;
1085                    bbftpd_storeunlink(realfilename) ;
1086                    return -1 ;
1087                }   
1088            }
1089        }
1090        /*
1091        ** Any other state
1092        */
1093        default : {
1094            bbftpd_log(BBFTPD_ERR,"Receive message in state %d",state) ;
1095            return -1 ;
1096        }
1097    }
1098}
1099       
1100       
Note: See TracBrowser for help on using the repository browser.