source: TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/bbftpd_private_user.c @ 1078

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

Implemented higher level auth message passing (the receiver doesn't
need to know the message length). The client will use this mechanism to
send the private string. This is working with stand alone bbftp client/server.

Embedded bbftpd is broken until I make corresponding
changes to the python API.

Line 
1/*
2 * bbftpd/bbftpd_private_user.c
3 * Copyright (C) 1999, 2000, 2001, 2002 IN2P3, CNRS
4 * bbftp@in2p3.fr
5 * http://doc.in2p3.fr/bbftp
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20 */
21
22/****************************************************************************
23
24
25
26 bbftpd_private_user.c  v 2.1.0 2001/05/21  - Routines creation
27
28*****************************************************************************/
29#include <netinet/in.h>
30#include <utime.h>
31
32#include <bbftpd.h>
33#include <daemon_proto.h>
34#include <structures.h>
35#include <syslog.h>
36
37#include <bbftpd_private_user.h>
38
39#ifdef NDG_PYTHON_EMBED
40#include <Python.h>
41#endif
42
43extern char currentusername[MAXLEN] ;
44
45#ifdef NDG_PYTHON_EMBED
46int bbftpd_private_auth_callback(char *logmessage);
47
48#endif
49
50/* prototypes */
51static int ndg_message_recv(char **buffer, int *length, char *logmessage);
52static int ndg_message_send(char *buffer, int length, char *logmessage);
53
54
55
56/*******************************************************************************
57** bbftpd_private_auth :                                                       *
58**                                                                             *
59**      Routine to do the private authentication. This routine just have to    *
60**      send or to receive private data to the bbftpd daemon. For that it will *
61**      use the two routines :                                                 *
62**          bbftpd_private_send                                                *
63**          bbftpd_private_recv                                                *
64**      The reception of the OK or BAD message will be done by the calling     *
65**      routine, so if this routine has no check to do (for example just       *
66**      sending username and password) it will just call bbftp_private_send    *
67**      twice and let the calling program check if it is OK or BAD.            *
68**                                                                             *
69**      The bbftp_private_send routine has to be called with the following     *
70**      parameters:                                                            *
71**                                                                             *
72**      int bbftpd_private_send(char *buffertosend,int buffertosendlength,     *
73**                             char *logmessage)                               *
74**          char    *buffertosend = string to be send to the daemon            *
75**          int     buffertosendlength = length of the string                  *
76**          char    *logmessage                                                *
77**                                                                             *
78**      and return 0 in case of success, -1 in case of error with logmessage   *
79**      filled                                                                 *
80**                                                                             *
81**      The bbftpd_private_recv routine has to be called with the following    *
82**      parameters:                                                            *
83**                                                                             *
84**      int bbftpd_private_recv(char *buffertorecv,int lengthtoreceive,        *
85**                             char *logmessage)                               *
86**          char    *buffertorecv = string to be send to the daemon            *
87**          int     lengthtorecv = length to be received                       *
88**          char    *logmessage                                                *
89**                                                                             *
90**      and return number of byte received in case of success, -1 in case of   *
91**      error with logmessage filled                                           *
92**      It is the duty of the programmer to take care that the buffer is large *
93**      enought                                                                *
94**                                                                             *
95**                                                                             *
96**      OUPUT variable :                                                       *
97**          logmessage :  to write the error message in case of error          *
98**                                                                             *
99**      GLOBAL VARIABLE USED :                                                 *
100**                                                                             *
101**                                                                             *
102**      RETURN:                                                                *
103**          -1  Unrecoverable error                                            *
104**           0  OK                                                             *
105**                                                                             *
106*******************************************************************************/
107
108int bbftpd_private_auth(char *logmessage)
109{
110
111#ifdef NDG_PYTHON_EMBED
112  char *username;
113
114  if (bbftpd_private_auth_callback(logmessage) == -1) {
115    return -1;
116  }
117  if ((username = bbftpd_private_auth_getusername(logmessage)) == NULL) {
118    return -1;
119  }
120   
121  sprintf(currentusername, "%.*s", MAXLEN, username);
122#else
123  char *privatestr;
124  int privatestr_len;
125
126  char msg[NDG_MESSAGE_LEN];
127  /* Receive version verification message.  */
128  if (bbftpd_private_recv(msg, NDG_MESSAGE_LEN, logmessage) == -1) {
129    return -1;
130  }
131  else {
132    syslog(LOG_DEBUG, "Received auth message: %s", msg);
133  }
134
135  /* Send response */
136  sprintf(msg, "%.*s", NDG_MESSAGE_LEN - 1, NDG_HANDSHAKE);
137  if (bbftpd_private_send(msg, NDG_MESSAGE_LEN, logmessage) == -1) {
138    return -1;
139  }
140
141  /* Receive the privatestr */
142  if (ndg_message_recv(&privatestr, &privatestr_len, logmessage) == -1) {
143    return -1;
144  }
145
146  syslog(LOG_INFO, "Private string: %s", privatestr);
147
148#endif
149
150  return 0 ;
151}
152
153
154#ifdef NDG_AUTH
155
156/*
157** bbftpd_private_authz_control :
158**
159**    Routine to authorise bbftp control commands. 
160**
161**    INPUT variables:
162**        msgcode : The message code from struct message
163**        transferoptions : TROPT_* options
164**        path : path to apply command to
165**
166**    OUTPUT variables:
167**        logmessage : to write the error message in case of failure
168**
169**    RETURN:
170**       -1  Authorisation failed
171**        0  OK
172**
173**
174*/
175int bbftpd_private_authz_control(int msgcode, int transferoption, char *path, char *logmessage)
176{
177
178  switch (msgcode) {
179  case MSG_CHDIR_V2:
180    syslog(LOG_DEBUG, "Authz: MSG_DIR 0x%x %s", transferoption, path);
181    break;
182  case MSG_LIST_V2:
183    syslog(LOG_DEBUG, "Authz: MSG_LIST_V2 0x%x %s", transferoption, path);
184    break;
185  case MSG_MKDIR_V2:
186    syslog(LOG_DEBUG, "Authz: MSG_MKDIR_V2 0x%x %s", transferoption, path);
187    break;
188  case MSG_RM:
189    syslog(LOG_DEBUG, "Authz: MSG_RM 0x%x %s", transferoption, path);
190    break;
191  case MSG_STAT:
192    syslog(LOG_DEBUG, "Authz: MSG_STAT 0x%x %s", transferoption, path);
193    break;
194  case MSG_DF:
195    syslog(LOG_DEBUG, "Authz: MSG_DF 0x%x %s", transferoption, path);
196    break;
197  default:
198    sprintf(logmessage, "Unrecognised message to authorise %d", msgcode);
199    return -1;
200  }
201
202  return 0;
203}
204
205
206/*
207** bbftpd_private_authz_retr :
208**
209**     Routine to authorise file retrieve requests.
210**
211**     INPUT variables:
212**         path: the file to retrieve
213**
214**    OUTPUT variables:
215**        logmessage : to write the error message in case of failure
216**
217**    RETURN:
218**       -1  Authorisation failed
219**        0  OK
220**
221*/
222int bbftpd_private_authz_retr(char *path, char *logmessage)
223{
224  syslog(LOG_DEBUG, "Authz: RETR %s", path);
225  return 0;
226}
227
228/*
229** bbftpd_private_authz_store :
230**
231**     Routine to authorise file store requests.
232**
233**     INPUT variables:
234**         path: the file to store
235**
236**    OUTPUT variables:
237**        logmessage : to write the error message in case of failure
238**
239**    RETURN:
240**       -1  Authorisation failed
241**        0  OK
242**
243*/
244
245int bbftpd_private_authz_store(char *path, char *logmessage)
246{
247  syslog(LOG_DEBUG, "Authz: STORE %s", path);
248  return 0;
249}
250
251
252/*
253 * Higher level message transfer functions.
254 *
255 */
256
257/**
258 * Send a message, declaring it's length to the client.
259 *
260 * @param buffer a pointer to the message buffer
261 * @param length the number of bytes to send
262 * @param[out] loggmessage is filled with the error message on error
263 * @return 0 if OK, -1 if error
264 */
265static int ndg_message_send(char *buffer, int length, char *logmessage) {
266  char ctrl[NDG_MESSAGE_LEN];
267
268  sprintf(ctrl, "NDG-msg: %i", length);
269  if (bbftpd_private_send(ctrl, NDG_MESSAGE_LEN, logmessage) == -1) {
270    return -1;
271  }
272
273  if (bbftpd_private_send(buffer, length, logmessage) == -1) {
274    return -1;
275  }
276
277  return 0;
278}
279
280/**
281 * Receive a message of variable length
282 *
283 * @param[out] buffer is set to newly allocated message buffer
284 * @param[out] length is set to the length of the message
285 * @param[out] logmessage is filled with the logmessage on error
286 * @return 0 if OK, -1 if error
287 */
288static int ndg_message_recv(char **buffer, int *length, char *logmessage) {
289  char ctrl[NDG_MESSAGE_LEN];
290
291  if (bbftpd_private_recv(ctrl, NDG_MESSAGE_LEN, logmessage) == -1) {
292    return -1;
293  }
294  if (sscanf(ctrl, "NDG-msg: %i", length) != 1) {
295    sprintf(logmessage, "ndg_message_recv ctrl error: %40s", ctrl);
296    return -1;
297  }
298
299  if ((*buffer = (char *)malloc(*length * sizeof(char))) == NULL) {
300    sprintf(logmessage, "ngd_message_recv malloc error");
301    return -1;
302  }
303
304  if (bbftpd_private_recv(*buffer, *length, logmessage) == -1) {
305    free(*buffer); *buffer = NULL;
306    return -1;
307  }
308
309  return 0;
310}
311 
312
313
314
315#endif // NDG_AUTH
Note: See TracBrowser for help on using the repository browser.