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

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

Python code on the server will now receive the private string from the
client. This is the basic requirement for doing bbftp authentication
within python.

Slightly higher level message passing functions ndg_message_send/recv are now
bound to python callbacks bbftpd.send and bbftpd.recv.

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
51
52/*******************************************************************************
53** bbftpd_private_auth :                                                       *
54**                                                                             *
55**      Routine to do the private authentication. This routine just have to    *
56**      send or to receive private data to the bbftpd daemon. For that it will *
57**      use the two routines :                                                 *
58**          bbftpd_private_send                                                *
59**          bbftpd_private_recv                                                *
60**      The reception of the OK or BAD message will be done by the calling     *
61**      routine, so if this routine has no check to do (for example just       *
62**      sending username and password) it will just call bbftp_private_send    *
63**      twice and let the calling program check if it is OK or BAD.            *
64**                                                                             *
65**      The bbftp_private_send routine has to be called with the following     *
66**      parameters:                                                            *
67**                                                                             *
68**      int bbftpd_private_send(char *buffertosend,int buffertosendlength,     *
69**                             char *logmessage)                               *
70**          char    *buffertosend = string to be send to the daemon            *
71**          int     buffertosendlength = length of the string                  *
72**          char    *logmessage                                                *
73**                                                                             *
74**      and return 0 in case of success, -1 in case of error with logmessage   *
75**      filled                                                                 *
76**                                                                             *
77**      The bbftpd_private_recv routine has to be called with the following    *
78**      parameters:                                                            *
79**                                                                             *
80**      int bbftpd_private_recv(char *buffertorecv,int lengthtoreceive,        *
81**                             char *logmessage)                               *
82**          char    *buffertorecv = string to be send to the daemon            *
83**          int     lengthtorecv = length to be received                       *
84**          char    *logmessage                                                *
85**                                                                             *
86**      and return number of byte received in case of success, -1 in case of   *
87**      error with logmessage filled                                           *
88**      It is the duty of the programmer to take care that the buffer is large *
89**      enought                                                                *
90**                                                                             *
91**                                                                             *
92**      OUPUT variable :                                                       *
93**          logmessage :  to write the error message in case of error          *
94**                                                                             *
95**      GLOBAL VARIABLE USED :                                                 *
96**                                                                             *
97**                                                                             *
98**      RETURN:                                                                *
99**          -1  Unrecoverable error                                            *
100**           0  OK                                                             *
101**                                                                             *
102*******************************************************************************/
103
104int bbftpd_private_auth(char *logmessage)
105{
106
107#ifdef NDG_PYTHON_EMBED
108  char *username;
109 
110  if (bbftpd_private_auth_callback(logmessage) == -1) {
111    return -1;
112  }
113  if ((username = bbftpd_private_auth_getusername(logmessage)) == NULL) {
114    return -1;
115  }
116 
117  sprintf(currentusername, "%.*s", MAXLEN, username);
118#else
119  char *privatestr;
120  int privatestr_len;
121 
122  char *msg;
123  int len;
124 
125  /* Receive version verification message.  */
126  if (ndg_message_recv(&msg, &len, logmessage) == -1) {
127    return -1;
128  }
129  syslog(LOG_DEBUG, "Received auth message: %s", msg);
130  free(msg);
131
132  /* Send response */
133  if (ndg_message_send(NDG_HANDSHAKE, strlen(NDG_HANDSHAKE) + 1, logmessage) == -1) {
134    return -1;
135  }
136
137  /* Receive the privatestr */
138  if (ndg_message_recv(&privatestr, &privatestr_len, logmessage) == -1) {
139    return -1;
140  }
141
142  syslog(LOG_INFO, "Private string: %s", privatestr);
143  free(privatestr);
144
145#endif
146
147  return 0 ;
148}
149
150
151#ifdef NDG_AUTH
152
153/*
154** bbftpd_private_authz_control :
155**
156**    Routine to authorise bbftp control commands. 
157**
158**    INPUT variables:
159**        msgcode : The message code from struct message
160**        transferoptions : TROPT_* options
161**        path : path to apply command to
162**
163**    OUTPUT variables:
164**        logmessage : to write the error message in case of failure
165**
166**    RETURN:
167**       -1  Authorisation failed
168**        0  OK
169**
170**
171*/
172int bbftpd_private_authz_control(int msgcode, int transferoption, char *path, char *logmessage)
173{
174
175  switch (msgcode) {
176  case MSG_CHDIR_V2:
177    syslog(LOG_DEBUG, "Authz: MSG_DIR 0x%x %s", transferoption, path);
178    break;
179  case MSG_LIST_V2:
180    syslog(LOG_DEBUG, "Authz: MSG_LIST_V2 0x%x %s", transferoption, path);
181    break;
182  case MSG_MKDIR_V2:
183    syslog(LOG_DEBUG, "Authz: MSG_MKDIR_V2 0x%x %s", transferoption, path);
184    break;
185  case MSG_RM:
186    syslog(LOG_DEBUG, "Authz: MSG_RM 0x%x %s", transferoption, path);
187    break;
188  case MSG_STAT:
189    syslog(LOG_DEBUG, "Authz: MSG_STAT 0x%x %s", transferoption, path);
190    break;
191  case MSG_DF:
192    syslog(LOG_DEBUG, "Authz: MSG_DF 0x%x %s", transferoption, path);
193    break;
194  default:
195    sprintf(logmessage, "Unrecognised message to authorise %d", msgcode);
196    return -1;
197  }
198
199  return 0;
200}
201
202
203/*
204** bbftpd_private_authz_retr :
205**
206**     Routine to authorise file retrieve requests.
207**
208**     INPUT variables:
209**         path: the file to retrieve
210**
211**    OUTPUT variables:
212**        logmessage : to write the error message in case of failure
213**
214**    RETURN:
215**       -1  Authorisation failed
216**        0  OK
217**
218*/
219int bbftpd_private_authz_retr(char *path, char *logmessage)
220{
221  syslog(LOG_DEBUG, "Authz: RETR %s", path);
222  return 0;
223}
224
225/*
226** bbftpd_private_authz_store :
227**
228**     Routine to authorise file store requests.
229**
230**     INPUT variables:
231**         path: the file to store
232**
233**    OUTPUT variables:
234**        logmessage : to write the error message in case of failure
235**
236**    RETURN:
237**       -1  Authorisation failed
238**        0  OK
239**
240*/
241
242int bbftpd_private_authz_store(char *path, char *logmessage)
243{
244  syslog(LOG_DEBUG, "Authz: STORE %s", path);
245  return 0;
246}
247
248
249/*
250 * Higher level message transfer functions.
251 *
252 */
253
254/**
255 * Send a message, declaring it's length to the client.
256 *
257 * @param buffer a pointer to the message buffer
258 * @param length the number of bytes to send
259 * @param[out] loggmessage is filled with the error message on error
260 * @return 0 if OK, -1 if error
261 */
262int ndg_message_send(char *buffer, int length, char *logmessage) {
263  char ctrl[NDG_MESSAGE_LEN];
264
265  sprintf(ctrl, "NDG-msg: %i", length);
266  if (bbftpd_private_send(ctrl, NDG_MESSAGE_LEN, logmessage) == -1) {
267    return -1;
268  }
269
270  if (bbftpd_private_send(buffer, length, logmessage) == -1) {
271    return -1;
272  }
273
274  return 0;
275}
276
277/**
278 * Receive a message of variable length
279 *
280 * @param[out] buffer is set to newly allocated message buffer
281 * @param[out] length is set to the length of the message
282 * @param[out] logmessage is filled with the logmessage on error
283 * @return 0 if OK, -1 if error
284 */
285int ndg_message_recv(char **buffer, int *length, char *logmessage) {
286  char ctrl[NDG_MESSAGE_LEN];
287
288  if (bbftpd_private_recv(ctrl, NDG_MESSAGE_LEN, logmessage) == -1) {
289    return -1;
290  }
291  if (sscanf(ctrl, "NDG-msg: %i", length) != 1) {
292    sprintf(logmessage, "ndg_message_recv ctrl error: %40s", ctrl);
293    return -1;
294  }
295
296  if ((*buffer = (char *)malloc(*length * sizeof(char))) == NULL) {
297    sprintf(logmessage, "ngd_message_recv malloc error");
298    return -1;
299  }
300
301  if (bbftpd_private_recv(*buffer, *length, logmessage) == -1) {
302    free(*buffer); *buffer = NULL;
303    return -1;
304  }
305
306  return 0;
307}
308 
309
310
311
312#endif // NDG_AUTH
Note: See TracBrowser for help on using the repository browser.