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

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

Added the autorisation hook bbftpd_private_authz. It appears to be called
correctly for a dir command.

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