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

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

Eliminated all "implicit declaration" warnings from "python setup.py
build"

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 <stdlib.h>
44#include <bbftpd_private_log.h>
45#include <utime.h>
46#include <sys/types.h>
47#include <sys/stat.h>
48#include <unistd.h>
49#if HAVE_STRING_H
50# include <string.h>
51#endif
52
53#include <netinet/in.h>
54#include <common.h>
55#include <daemon.h>
56#include <daemon_proto.h>
57#include <status.h>
58#include <structures.h>
59#include <version.h>
60
61#ifdef NDG_AUTH
62# include "ndg.h"
63#endif
64
65extern int  state ;
66extern int  incontrolsock ;
67extern int  outcontrolsock ;
68extern  int     recvcontrolto ;
69extern  int     sendcontrolto ;
70extern char *curfilename ;
71extern char *realfilename ;
72extern int  curfilenamelen ;
73extern int  transferoption ;
74extern int  filemode ;
75extern char lastaccess[9] ;
76extern char lastmodif[9] ;
77extern int  sendwinsize ;       
78extern int  recvwinsize ;       
79extern int  buffersizeperstream ;
80extern int  requestedstreamnumber ;
81extern my64_t  filesize ;
82extern int  *myports ;
83extern int  *mychildren ;
84extern int  *mysockets ;
85extern int  myumask ;
86extern int  mycos ;
87extern char *readbuffer ;
88extern char *compbuffer ;
89extern int  protocolversion ;
90extern  char            currentusername[MAXLEN] ;
91
92#ifndef WORDS_BIGENDIAN
93# ifndef HAVE_NTOHLL
94my64_t    ntohll(my64_t v) ;
95# endif
96#endif
97
98int bbftpd_readcontrol(int msgcode,int msglen) 
99{
100
101    int        retcode ;
102    int        i ;
103    char    *receive_buffer ;
104    int     oldumask, newumask ;
105    struct  message *msg ;
106    struct  mess_store_v2 *msg_store_v2 ;
107    struct  mess_integer *msg_integer ;
108    struct  mess_dir *msg_dir ;
109    char    logmessage[1024] ;
110    int     *portfree ;
111    struct utimbuf ftime ;
112    int     *porttosend ;   
113    /*
114    ** Depending on the state the accepted message may be different
115    */
116#ifndef WORDS_BIGENDIAN
117    msglen = ntohl(msglen) ;
118#endif
119    switch (state) {
120        /*
121        ** Case S_LOGGED :
122        **      Nothing is going on, so message accepted are :
123        **
124        **         MSG_CHCOS
125        **         MSG_CHDIR_V2
126        **         MSG_CHUMASK
127        **         MSG_CLOSE_CONN
128        **         MSG_LIST_V2
129        **         MSG_MKDIR_V2
130        **         MSG_RETR_V2
131        **         MSG_STORE_V2
132        **
133        */
134           case S_LOGGED : {
135            switch (msgcode) {
136           
137                case MSG_CHCOS : {
138                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CHCOS, msglen = %d",msglen) ;
139                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
140                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_CHCOS : %s",strerror(errno)) ;
141                        reply(MSG_BAD,"Error allocating memory for MSG_CHCOS") ;
142                        return 0 ;
143                    }
144                    if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
145                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_CHCOS") ;
146                        FREE(receive_buffer) ;
147                        return -1 ;
148                    }
149                    msg_integer = (struct  mess_integer *) receive_buffer ;
150#ifndef WORDS_BIGENDIAN
151                    mycos = ntohl(msg_integer->myint) ;
152#else
153                    mycos = msg_integer->myint ;
154#endif
155                    if (mycos>=0) {
156                        bbftpd_log(BBFTPD_DEBUG,"Cos set to %d",mycos) ;
157                        reply(MSG_OK,"COS set") ;
158                    } else {
159                        bbftpd_log(BBFTPD_DEBUG,"Cos received : %d",mycos) ;
160                        reply(MSG_OK,"COS not set") ;
161                    }
162                    FREE(receive_buffer) ;
163                    return 0 ;
164               }
165
166                case MSG_CHDIR_V2 : {
167                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CHDIR_V2, msglen = %d",msglen) ;
168                    retcode = bbftpd_cd(incontrolsock,msglen) ;
169                    return retcode ;
170                }
171               
172                case MSG_CHUMASK : {
173                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_UMASK ") ;
174                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
175                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_UMASK : %s",strerror(errno)) ;
176                        reply(MSG_BAD,"Error allocating memory for MSG_UMASK") ;
177                        return 0 ;
178                    }
179                    if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
180                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_UMASK") ;
181                        FREE(receive_buffer) ;
182                        return -1 ;
183                    }
184                    msg_integer = (struct  mess_integer *) receive_buffer ;
185#ifndef WORDS_BIGENDIAN
186                    myumask = ntohl(msg_integer->myint) ;
187#else
188                    myumask = msg_integer->myint ;
189#endif
190                    /*
191                    ** We reset the umask first then call twice the umask
192                    ** in order to see the real umask set
193                    */
194                    oldumask = umask(0) ;
195                    umask(myumask) ;
196                    newumask = umask(myumask) ;
197                    sprintf(logmessage,"umask changed from %04o to %04o",oldumask,newumask) ;
198                    reply(MSG_OK,logmessage) ;
199                    FREE(receive_buffer) ;
200                    return 0 ;
201                }
202 
203                case MSG_CLOSE_CONN : {
204                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_CLOSE_CONN, msglen = %d",msglen) ;
205                    return -1 ;
206                }
207               
208               
209                case MSG_LIST_V2 :{
210                   bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_LIST_V2 ") ;
211                   if ( (receive_buffer = (char *) malloc (msglen+1) ) == NULL ) {
212                        bbftpd_log(BBFTPD_ERR,"Unable to malloc space for directory name (%d)",msglen) ;
213                        reply(MSG_BAD,"Unable to malloc space for directory name") ;
214                       return 0 ;
215                   }
216                  /*
217                   ** Read the characteristics of the directory
218                   */
219                   if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
220                       /*
221                       ** Error ...
222                       */
223                        bbftpd_log(BBFTPD_ERR,"Error reading directory name") ;
224                       FREE(receive_buffer) ;
225                       return -1 ;
226                   }
227                   /*
228                   ** buffer contains the directory to create
229                   */
230                   receive_buffer[msglen] = '\0' ;
231                   msg_dir = (struct mess_dir *) receive_buffer ;
232#ifdef NDG_AUTH
233                    if (bbftpd_private_authz_control(msgcode, msg_dir->transferoption, msg_dir->dirname,
234                                                     logmessage) != 0) {
235                      bbftpd_log(BBFTPD_ERR, logmessage);
236                      reply(MSG_BAD, logmessage);
237                      FREE(receive_buffer);
238                      return 0;
239                    }
240#endif // NDG_AUTH
241                   transferoption  = msg_dir->transferoption ;
242                   bbftpd_log(BBFTPD_DEBUG,"Pattern = %s",msg_dir->dirname) ;
243                   retcode = bbftpd_list(msg_dir->dirname,logmessage) ;
244                   FREE(receive_buffer) ;
245                   return retcode ;
246                }
247               
248                case MSG_MKDIR_V2 : {
249                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_MKDIR_V2 ") ;
250                    retcode = bbftpd_mkdir(incontrolsock,msglen) ;
251                    return retcode ;
252                }
253               
254                case MSG_RM : {
255                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_RM ") ;
256                    retcode = bbftpd_rm(incontrolsock,msglen) ;
257                    return retcode ;
258                }
259               
260                case MSG_STAT : {
261                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_STAT ") ;
262                    retcode = bbftpd_stat(incontrolsock,msglen) ;
263                    return retcode ;
264                }
265                   
266                case MSG_DF : {
267                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_DF ") ;
268                    retcode = bbftpd_statfs(incontrolsock,msglen) ;
269                    return retcode ;
270                }
271                   
272                case MSG_RETR_V2 : {
273                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_RETR_V2") ;
274                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
275                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_RETR_V2 : %s",strerror(errno)) ;
276                        return -1 ;
277                    }
278                     if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
279                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_RETR_V2") ;
280                        FREE(receive_buffer) ;
281                        return -1 ;
282                    }
283                    msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
284
285                    /*
286                    ** Set up the transfer parameter, we are going only to store
287                    ** them
288                    */
289#ifndef WORDS_BIGENDIAN
290                    transferoption          = msg_store_v2->transferoption ;
291                    sendwinsize             = ntohl(msg_store_v2->sendwinsize) ;
292                    recvwinsize             = ntohl(msg_store_v2->recvwinsize) ;
293                    buffersizeperstream     = ntohl(msg_store_v2->buffersizeperstream) ;
294                    requestedstreamnumber   = ntohl(msg_store_v2->nbstream) ;
295#else
296                    transferoption          = msg_store_v2->transferoption ;
297                    sendwinsize             = msg_store_v2->sendwinsize ;
298                    recvwinsize             = msg_store_v2->recvwinsize ;
299                    buffersizeperstream     = msg_store_v2->buffersizeperstream ;
300                    requestedstreamnumber   = msg_store_v2->nbstream ;
301#endif
302                    bbftpd_log(BBFTPD_DEBUG,"transferoption         = %d ",transferoption) ;
303                    bbftpd_log(BBFTPD_DEBUG,"sendwinsize            = %d ",sendwinsize) ;
304                    bbftpd_log(BBFTPD_DEBUG,"recvwinsize            = %d ",recvwinsize) ;
305                    bbftpd_log(BBFTPD_DEBUG,"buffersizeperstream    = %d ",buffersizeperstream) ;
306                    bbftpd_log(BBFTPD_DEBUG,"requestedstreamnumber  = %d ",requestedstreamnumber) ;
307                    state = S_WAITING_FILENAME_RETR ;
308                    FREE(receive_buffer) ;
309                    return 0 ;
310                }
311               
312                case MSG_STORE_V2 :{
313                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_STORE_V2") ;
314                    if ( (receive_buffer = (char *) malloc (msglen)) == NULL ) {
315                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_STORE_V2 : %s",strerror(errno)) ;
316                        return -1 ;
317                    }
318                     if ( readmessage(incontrolsock,receive_buffer,msglen,recvcontrolto) < 0 ) {
319                        bbftpd_log(BBFTPD_ERR,"Error reading MSG_STORE_V2") ;
320                        FREE(receive_buffer) ;
321                        return -1 ;
322                    }
323                    msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
324
325                    /*
326                    ** Set up the transfer parameter, we are going only to store
327                    ** them
328                    */
329#ifndef WORDS_BIGENDIAN
330                    transferoption          = msg_store_v2->transferoption ;
331                    filemode                = ntohl(msg_store_v2->filemode) ;
332                    strncpy(lastaccess,msg_store_v2->lastaccess,8) ;
333                    lastaccess[8] = '\0' ;
334                    strncpy(lastmodif,msg_store_v2->lastmodif,8) ;
335                    lastmodif[8] = '\0' ;
336                    sendwinsize             = ntohl(msg_store_v2->sendwinsize) ;
337                    recvwinsize             = ntohl(msg_store_v2->recvwinsize) ;
338                    buffersizeperstream     = ntohl(msg_store_v2->buffersizeperstream) ;
339                    requestedstreamnumber   = ntohl(msg_store_v2->nbstream) ;
340                    filesize                = ntohll(msg_store_v2->filesize) ;
341#else
342                    transferoption          = msg_store_v2->transferoption ;
343                    filemode                = msg_store_v2->filemode ;
344                    strncpy(lastaccess,msg_store_v2->lastaccess,8) ;
345                    lastaccess[8] = '\0' ;
346                    strncpy(lastmodif,msg_store_v2->lastmodif,8) ;
347                    lastmodif[8] = '\0' ;
348                    sendwinsize             = msg_store_v2->sendwinsize ;
349                    recvwinsize             = msg_store_v2->recvwinsize ;
350                    buffersizeperstream     = msg_store_v2->buffersizeperstream ;
351                    requestedstreamnumber   = msg_store_v2->nbstream ;
352                    filesize                = msg_store_v2->filesize ;
353#endif
354                    bbftpd_log(BBFTPD_DEBUG,"transferoption         = %d ",transferoption) ;
355                    bbftpd_log(BBFTPD_DEBUG,"filemode               = %d ",filemode) ;
356                    bbftpd_log(BBFTPD_DEBUG,"lastaccess             = %s ",lastaccess) ;
357                    bbftpd_log(BBFTPD_DEBUG,"lastmodif              = %s ",lastmodif) ;
358                    bbftpd_log(BBFTPD_DEBUG,"sendwinsize            = %d ",sendwinsize) ;
359                    bbftpd_log(BBFTPD_DEBUG,"recvwinsize            = %d ",recvwinsize) ;
360                    bbftpd_log(BBFTPD_DEBUG,"buffersizeperstream    = %d ",buffersizeperstream) ;
361                    bbftpd_log(BBFTPD_DEBUG,"requestedstreamnumber  = %d ",requestedstreamnumber) ;
362                    bbftpd_log(BBFTPD_DEBUG,"filesize               = %" LONG_LONG_FORMAT " ",filesize) ;
363                    state = S_WAITING_FILENAME_STORE ;
364                    FREE(receive_buffer) ;
365                    return 0 ;
366                }
367               
368                default :{
369                    bbftpd_log(BBFTPD_ERR,"Unkown message in logged state %d",msgcode) ;
370                    retcode = discardmessage(incontrolsock,msglen,recvcontrolto) ;
371                    reply(MSG_BAD_NO_RETRY,"Unkown message in S_LOGGED state") ;
372                    return retcode ;
373                }
374            }
375        }
376        /*
377        ** Case S_WAITING_FILENAME_STORE
378        **
379        **         MSG_FILENAME
380        */
381           case S_WAITING_FILENAME_STORE : {
382            switch (msgcode) {
383                case MSG_FILENAME :{
384                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_FILENAME in S_WAITING_FILENAME_STORE state") ;
385                    if ( msglen == 0 ) {
386                         bbftpd_log(BBFTPD_ERR,"Filename length null") ;
387                         return -1 ;
388                    }
389                    if ( (curfilename = (char *) malloc (msglen+1)) == NULL ) {
390                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for filename : %s",strerror(errno)) ;
391                        return -1 ;
392                    }
393                    /* tmp name = <name>.bbftp.tmp.<hostname in 10 chars>.<pid in 5 chars> */
394                    if ( (realfilename = (char *) malloc (msglen+30)) == NULL ) {
395                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for realfilename : %s",strerror(errno)) ;
396                        free_all_var() ;
397                        return -1 ;
398                    }
399                    if ( readmessage(incontrolsock,curfilename,msglen,recvcontrolto) < 0 ) {
400                        bbftpd_log(BBFTPD_ERR,"Error reading filename") ;
401                        free_all_var() ;
402                        return -1 ;
403                    }
404                    curfilename[msglen] = '\0' ;
405                    curfilenamelen = msglen ;
406                    bbftpd_log(BBFTPD_DEBUG,"Request to store file %s",curfilename) ;
407#ifdef NDG_AUTH
408                    if (bbftpd_private_authz_store(curfilename, logmessage) != 0) {
409                      bbftpd_log(BBFTPD_ERR, logmessage);
410                      reply(MSG_BAD_NO_RETRY, logmessage);
411                      free_all_var();
412                      state = S_LOGGED;
413                      return 0;
414                    }
415#endif // NDG_AUTH
416                    if ( (retcode = bbftpd_storecheckoptions(logmessage)) < 0 ) {
417                        bbftpd_log(BBFTPD_ERR,logmessage) ;
418                        reply(MSG_BAD_NO_RETRY,logmessage) ;
419                        free_all_var() ;
420                        state = S_LOGGED ;
421                        return 0 ;
422                    }
423                    /*
424                    ** Options are corrects
425                    */
426                    if ( (transferoption & TROPT_TMP ) == TROPT_TMP ) {
427                        /*
428                        ** Caculate tempfile name if TROPT_TMP is set
429                        ** To avoid multiple access to temp file in HPSS
430                        ** file is called .bbftp.tmp.$host.$pid
431                        */
432                        char hostname[10 + 1];
433                        if (gethostname(hostname, sizeof(hostname)) < 0) {
434                                sprintf(realfilename,"%s.bbftp.tmp.%d",curfilename,getpid());
435                        } else {
436                                hostname[sizeof(hostname) - 1] = '\0';
437                                sprintf(realfilename,"%s.bbftp.tmp.%s.%d",curfilename,hostname,getpid()) ;
438                        }
439                    } else {
440                        sprintf(realfilename,"%s",curfilename) ;
441                    }
442                    /*
443                    ** Create the file
444                    */
445                    if ( (retcode = bbftpd_storecreatefile(realfilename,logmessage)) < 0 ) {
446                        bbftpd_log(BBFTPD_ERR,logmessage) ;
447                        reply(MSG_BAD_NO_RETRY,logmessage) ;
448                        free_all_var() ;
449                        state = S_LOGGED ;
450                        return 0 ;
451                    } else if ( retcode > 0 ) {
452                        bbftpd_log(BBFTPD_ERR,logmessage) ;
453                        reply(MSG_BAD,logmessage) ;
454                        free_all_var() ;
455                        state = S_LOGGED ;
456                        return 0 ;
457                    } else {
458                        if ( filesize == 0 ) {
459                            if ((transferoption & TROPT_ACC ) == TROPT_ACC ) {
460                                sscanf(lastaccess,"%08x",&ftime.actime) ;
461                                sscanf(lastmodif,"%08x",&ftime.modtime) ;
462                                if ( bbftpd_storeutime(realfilename,&ftime,logmessage) < 0 ) {
463                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
464                                    bbftpd_storeunlink(realfilename) ;
465                                    reply(MSG_BAD,logmessage) ;
466                                    free_all_var() ;
467                                    state = S_LOGGED ;
468                                    return 0 ;
469                                }
470                           }
471                           if ( (transferoption & TROPT_MODE ) == TROPT_MODE ) {
472                                if ( bbftpd_storechmod(realfilename,filemode,logmessage) < 0 ) {
473                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
474                                    bbftpd_storeunlink(realfilename) ;
475                                    reply(MSG_BAD,logmessage) ;
476                                    free_all_var() ;
477                                    state = S_LOGGED ;
478                                    return 0 ;
479                                }
480                            }
481                            if ( (transferoption & TROPT_TMP ) == TROPT_TMP ) {
482                                if ( bbftpd_storerename(realfilename,curfilename,logmessage) < 0 ) {
483                                    bbftpd_log(BBFTPD_ERR,logmessage) ;
484                                    bbftpd_storeunlink(realfilename) ;
485                                    reply(MSG_BAD,logmessage) ;
486                                    free_all_var() ;
487                                    state = S_LOGGED ;
488                                    return 0 ;
489                                }
490                            }
491                            reply(MSG_OK,"") ;
492                            free_all_var() ;
493                            state = S_LOGGED ;
494                            return 0 ;
495                        } else {
496                            /*
497                            ** We are reserving the memory for the ports
498                            */
499                            if ( (myports = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
500                                bbftpd_storeunlink(realfilename) ;
501                                free_all_var() ;
502                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for myports") ;
503                                sprintf(logmessage,"Unable to allocate memory for myports") ;
504                                reply(MSG_BAD,logmessage) ;
505                                state = S_LOGGED ;
506                                return 0 ;
507                            }
508                            /*
509                            ** We are reserving the memory for the children pid
510                            */
511                            if ( (mychildren = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL) {
512                                bbftpd_storeunlink(realfilename) ;
513                                free_all_var() ;
514                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for mychildren") ;
515                                sprintf(logmessage,"Unable to allocate memory for mychildren") ;
516                                reply(MSG_BAD,logmessage) ;
517                                state = S_LOGGED ;
518                                return 0 ;
519                            }
520                            /*
521                            ** We are reserving the memory for the readbuffer
522                            */
523                            if ( (readbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
524                                bbftpd_storeunlink(realfilename) ;
525                                free_all_var() ;
526                                bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for readbuffer") ;
527                                sprintf(logmessage,"Unable to allocate memory for readbuffer") ;
528                                reply(MSG_BAD,logmessage) ;
529                                state = S_LOGGED ;
530                                return 0 ;
531                            }
532                            /*
533                            ** We are reserving the memory for the compression buffer
534                            ** if needed
535                            */
536                            if ( (transferoption & TROPT_GZIP ) == TROPT_GZIP ) {
537                                if ( (compbuffer = (char *) malloc (buffersizeperstream*1024)) == NULL) {
538                                    bbftpd_storeunlink(realfilename) ;
539                                    free_all_var() ;
540                                    bbftpd_log(BBFTPD_ERR,"Unable to allocate memory for compbuffer") ;
541                                    sprintf(logmessage,"Unable to allocate memory for compbuffer") ;
542                                    reply(MSG_BAD,logmessage) ;
543                                    state = S_LOGGED ;
544                                    return 0 ;
545                                }
546                            }
547                            if ( (receive_buffer = (char *) malloc (STORMESSLEN_V2)) == NULL ) {
548                                bbftpd_storeunlink(realfilename) ;
549                                bbftpd_log(BBFTPD_ERR,"Error allocating memory for MSG_TRANS_OK_V2 : %s",strerror(errno)) ;
550                                free_all_var() ;
551                                sprintf(logmessage,"Unable to allocate memory for message MSG_TRANS_OK_V2") ;
552                                reply(MSG_BAD,logmessage) ;
553                                state = S_LOGGED ;
554                                return 0 ;
555                            }
556                            msg = (struct message *) receive_buffer ;
557                            if ( protocolversion == 2) { /* ACTIVE MODE */
558                              msg->code = MSG_TRANS_OK_V2 ;
559                            } else { /* PASSIVE MODE */
560                              msg->code = MSG_TRANS_OK_V3 ;
561                            }
562#ifndef WORDS_BIGENDIAN
563                            msg->msglen = ntohl(STORMESSLEN_V2) ;
564#else
565                            msg->msglen = STORMESSLEN_V2 ;
566#endif
567                            if ( writemessage(outcontrolsock,receive_buffer,MINMESSLEN,sendcontrolto) < 0 ) {
568                                bbftpd_log(BBFTPD_ERR,"Error wtiting MSG_TRANS_OK_V2 first part") ;
569                                bbftpd_storeunlink(realfilename) ;
570                                free_all_var() ;
571                                FREE(receive_buffer) ;
572                                return -1 ;
573                            }
574                            msg_store_v2 = (struct  mess_store_v2 *) receive_buffer ;
575                            /*
576                            ** Set up the transfer parameter
577                            */
578#ifndef WORDS_BIGENDIAN
579                            msg_store_v2->transferoption       = transferoption ;
580                            msg_store_v2->filemode             = ntohl(filemode) ;
581                            strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
582                            msg_store_v2->lastaccess[8] = '0' ;
583                            strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
584                            msg_store_v2->lastmodif[8] = '0' ;
585                            msg_store_v2->sendwinsize          = ntohl(sendwinsize) ;
586                            msg_store_v2->recvwinsize          = ntohl(recvwinsize) ;
587                            msg_store_v2->buffersizeperstream  = ntohl(buffersizeperstream) ;
588                            msg_store_v2->nbstream             = ntohl(requestedstreamnumber) ;
589                            msg_store_v2->filesize             = ntohll(filesize) ;
590#else
591                            msg_store_v2->transferoption       = transferoption  ;       
592                            msg_store_v2->filemode             =  filemode;
593                            strncpy(msg_store_v2->lastaccess,lastaccess,8) ;
594                            msg_store_v2->lastaccess[8] = '0' ;
595                            strncpy(msg_store_v2->lastmodif,lastmodif,8) ;
596                            msg_store_v2->lastmodif[8] = '0' ;
597                            msg_store_v2->sendwinsize          = sendwinsize ;
598                            msg_store_v2->recvwinsize          = recvwinsize ;
599                            msg_store_v2->buffersizeperstream  = buffersizeperstream ;
600                            msg_store_v2->nbstream             = requestedstreamnumber;
601                            msg_store_v2->filesize             = filesize ;
602#endif
603                            if ( writemessage(outcontrolsock,receive_buffer,STORMESSLEN_V2,sendcontrolto) < 0 ) {
604                                bbftpd_log(BBFTPD_ERR,"Error wtiting MSG_TRANS_OK_V2 second part") ;
605                                bbftpd_storeunlink(realfilename) ;
606                                free_all_var() ;
607                                FREE(receive_buffer) ;
608                                return -1 ;
609                            }
610                            /* PASSIVE MODE: send ports */
611                            if ( protocolversion >= 3 ) {
612                              /*
613                              ** We are reserving the memory for the ports
614                              */
615                              if ( (mysockets = (int *) malloc (requestedstreamnumber*sizeof(int))) == NULL ) {
616                                bbftpd_log(BBFTPD_ERR,"Error allocating space for sockets") ;
617                                bbftpd_storeunlink(realfilename) ;
618                                free_all_var() ;
619                                FREE(receive_buffer) ;
620                                return -1 ;
621                              }
622                              if ( bbftpd_getdatasock(requestedstreamnumber) < 0 ) {
623                                bbftpd_log(BBFTPD_ERR,"Error creating data sockets") ;
624                                bbftpd_storeunlink(realfilename) ;
625                                free_all_var() ;
626                                FREE(receive_buffer) ;
627                                return -1 ;
628                              }
629                              portfree = (int *)receive_buffer ;
630                              porttosend = myports ;
631                              for (i=0 ; i<requestedstreamnumber  ; i++) {
632#ifndef WORDS_BIGENDIAN
633                                *portfree++  = ntohl(ntohs(*porttosend++)) ;
634#else
635                                *portfree++ = *porttosend++ ;
636#endif
637                              }
638/*          bbftpd_log(BBFTPD_INFO,"Port=%d,socket=%d\n",*myports,*mysockets) ;*/
639                              if ( writemessage(outcontrolsock,receive_buffer,requestedstreamnumber*sizeof(int),sendcontrolto) < 0) {
640                                bbftpd_log(BBFTPD_ERR,"Error writing MSG_TRANS_OK_V3 (ports)") ;
641                                bbftpd_storeunlink(realfilename) ;
642                                free_all_var() ;
643                                FREE(receive_buffer) ;
644                                return -1 ;
645                              }
646                            } /* END PASSIVE MODE */
647                            state = S_WAITING_STORE_START ;
648                            FREE(receive_buffer) ;
649                            return 0 ;
650                        }
651                    }
652                }
653                default :{
654                    bbftpd_log(BBFTPD_ERR,"Unkown message in S_WAITING_FILENAME_STORE state : %d",msgcode) ;
655                    return -1 ;
656                }
657            }
658        }
659        /*
660        ** Case S_WAITING_FILENAME_RETR
661        **
662        **         MSG_FILENAME
663        */
664           case S_WAITING_FILENAME_RETR : {
665            switch (msgcode) {
666                case MSG_FILENAME :{
667                    bbftpd_log(BBFTPD_DEBUG,"Receiving MSG_FILENAME in S_WAITING_FILENAME_RETR state") ;
668                    if ( msglen == 0 ) {
669                         bbftpd_log(BBFTPD_ERR,"Filename length null") ;
670                         return -1 ;
671                    }
672                    if ( (curfilename = (char *) malloc (msglen+1)) == NULL ) {
673                        bbftpd_log(BBFTPD_ERR,"Error allocating memory for filename : %s",strerror(errno)) ;
674                        return -1 ;
675                    }
676                    if ( readmessage(incontrolsock,curfilename,msglen,recvcontrolto) < 0 ) {
677                        bbftpd_log(BBFTPD_ERR,"Error reading filename") ;
678                        free_all_var() ;
679                        return -1 ;
680                    }
681                    curfilename[msglen] = '\0' ;
682                    curfilenamelen = msglen ;
683                    bbftpd_log(BBFTPD_DEBUG,"Request to retreive file %s",curfilename) ;
684#ifdef NDG_AUTH
685                    if (bbftpd_private_authz_retr(curfilename, logmessage) != 0) {
686                      bbftpd_log(BBFTPD_ERR, logmessage);
687                      reply(MSG_BAD_NO_RETRY, logmessage);
688                      free_all_var();
689                      state = S_LOGGED;
690                      return 0;
691                    }
692#endif // NDG_AUTH
693                    /*
694                    ** Create the file
695                    */
696                    if ( (retcode = bbftpd_retrcheckfile(curfilename,logmessage)) < 0 ) {
697                        bbftpd_log(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                        bbftpd_log(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                                bbftpd_log(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                                bbftpd_log(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                                bbftpd_log(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                                    bbftpd_log(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                            bbftpd_log(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                            bbftpd_log(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                            bbftpd_log(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                            bbftpd_log(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                                bbftpd_log(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                                bbftpd_log(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/*          bbftpd_log(BBFTPD_INFO,"Port=%d,socket=%d\n",*myports,*mysockets) ;*/
859                              if ( writemessage(outcontrolsock,receive_buffer,requestedstreamnumber*sizeof(int),sendcontrolto) < 0) {
860                                bbftpd_log(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                    bbftpd_log(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                    bbftpd_log(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                        bbftpd_log(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                        bbftpd_log(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                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
950                    bbftpd_storeunlink(realfilename) ;
951                    free_all_var() ;
952                    state = S_LOGGED ;
953                    return 0 ;
954                }
955                default :{
956                    bbftpd_log(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                    bbftpd_log(BBFTPD_ERR,"Receive MSG_CREATE_ZERO message ") ;
973                    state = S_LOGGED ;
974                    return 0 ;
975                }
976                case MSG_ABORT : {
977                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
978                    state = S_LOGGED ;
979                    return 0 ;
980                }
981                default :{
982                    bbftpd_log(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                    bbftpd_log(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                        bbftpd_log(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                        bbftpd_log(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                        bbftpd_log(BBFTPD_ERR,"retrtransferfile retcode > 0") ;
1041                        free_all_var() ;
1042                        state = S_LOGGED ;
1043                        return 0 ;
1044                    }
1045                    /*
1046                    **
1047                    */
1048                    bbftpd_log(BBFTPD_ERR,"retrtransferfile retcode < 0") ;
1049                    free_all_var() ;
1050                    state = S_LOGGED ;
1051                    return -1 ;
1052                }
1053                case MSG_ABORT : {
1054                    bbftpd_log(BBFTPD_ERR,"Receive ABORT message") ;
1055                    free_all_var() ;
1056                    state = S_LOGGED ;
1057                    return 0 ;
1058                }
1059                default :{
1060                    bbftpd_log(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                    bbftpd_log(BBFTPD_ERR,"Receive MSG_ABORT while sending") ;
1072                    return -1 ;
1073                }
1074                default :{
1075                    bbftpd_log(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                    bbftpd_log(BBFTPD_ERR,"Receive MSG_ABORT while receiving") ;
1084                    bbftpd_storeclosecastfile(realfilename,logmessage) ;
1085                    bbftpd_storeunlink(realfilename) ;
1086                    return -1 ;
1087                }
1088                default :{
1089                    bbftpd_log(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            bbftpd_log(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.