source: TI05-delivery/trunk/src/bbftp-server-3.2.0/bbftpd/ndg.c @ 1430

/**
 * NDG python embedded bbftp daemon module.
 *
 * @author Stephen Pascoe
 *
 * Copyright (C) 2006 CCLRC & NERC
 *
 * This software may be distributed under the terms of the Q Public Licence, version 1.0 or later.
 *
 */

#ifdef NDG_PYTHON_EMBED
#include <Python.h>
#endif
#include <ndg.h>
#include <stdlib.h>
#include <stdio.h>
#if HAVE_STRING_H
# include <string.h>
#endif

/**
 * Routine to do private authentication.
 *
 * This function is the main entry point from bbftpd into the private authentication system.
 * See \c bbftpd_private_user.c for full details on the private authentication interface.
 *
 * @param logmessage a pointer to a buffer of length \c NDG_MAX_LOGMESSAGE
 *     for storing an error message when returning -1.
 * @return 0 on success or -1 on failure.
 */
int bbftpd_private_auth(char *logmessage) {

#ifdef NDG_PYTHON_EMBED
  char *username;
  
  if (ndg_auth(logmessage) == -1) {
    return -1;
  }
  if ((username = ndg_getusername(logmessage)) == NULL) {
    return -1;
  }
  
  sprintf(currentusername, "%.*s", MAXLEN, username);
#else
  char *privatestr;
  int privatestr_len;
  
  char *msg;
  int len;
  
  /* Receive version verification message.  */
  if (ndg_message_recv(&msg, &len, logmessage) == -1) {
    return -1;
  }
  bbftpd_log(LOG_DEBUG, "Received auth message: %s", msg);
  free(msg);

  /* Send response */
  if (ndg_message_send(NDG_HANDSHAKE, strlen(NDG_HANDSHAKE), logmessage) == -1) {
    return -1;
  }

  /* Receive the privatestr */
  if (ndg_message_recv(&privatestr, &privatestr_len, logmessage) == -1) {
    return -1;
  }

  bbftpd_log(LOG_INFO, "Private string: %s", privatestr);
  free(privatestr);

#endif

  return 0 ;
}

/**
 * Routine to authorise bbftp control commands.
 *
 * Commands that require authorisation but do not involve sending or retrieving a file
 * are authorised by this function.  The argument \a msgcode will be one of the following
 * constants defined in \c structures.h :
 * 
 *   \li \c MSG_CHDIR_V2 : a chdir request
 *   \li \c MSG_LIST_V2 : a ls/dir request
 *   \li \c MSG_MKDIR_V2 : a mkdir request
 *   \li \c MSG_RM : a rm request
 *   \li \c MSG_STAT : a stat request
 *   \li \c MSG_DF : a statfs request
 *
 * Each command is being applied to the file pointed to by \a path.  Some commands may be affected
 * by the value of \a transferoption.
 *
 * @param msgcode the message code from struct message.
 * @param transferoption \c TROPT_* options.
 * @param path the path to which the command applies.
 * @param logmessage pointer to a buffer of length \c NDG_MAX_LOGMESSAGE
 *     for storing an error message when returning -1.
 * @return 0 on success or -1 on authorisation failure.
 */
int bbftpd_private_authz_control(int msgcode, int transferoption, char *path, char *logmessage)
{

  switch (msgcode) {
  case MSG_CHDIR_V2:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_DIR 0x%x %s", transferoption, path);
    break;
  case MSG_LIST_V2:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_LIST_V2 0x%x %s", transferoption, path);
    break;
  case MSG_MKDIR_V2:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_MKDIR_V2 0x%x %s", transferoption, path);
    break;
  case MSG_RM:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_RM 0x%x %s", transferoption, path);
    break;
  case MSG_STAT:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_STAT 0x%x %s", transferoption, path);
    break;
  case MSG_DF:
    bbftpd_log(LOG_DEBUG, "Authz: MSG_DF 0x%x %s", transferoption, path);
    break;
  default:
    sprintf(logmessage, "Unrecognised message to authorise %d", msgcode);
    return -1;
  }

#ifdef NDG_PYTHON_EMBED
  return ndg_authz_control(msgcode, transferoption, path, logmessage);
#else
  return 0;
#endif // NDG_PYTHON_EMBED
}


/**
 * Routine to authorise file retrieve requests.
 *
 * The client is requesting the retrieval of the file \a path.
 *
 * @param path the file being retrieved.
 * @param logmessage pointer to a buffer of length \c NDG_MAX_LOGMESSAGE
 *     for storing an error message when returning -1.
 * @return 0 on success or -1 on authorisation failure.
 */
int bbftpd_private_authz_retr(char *path, char *logmessage)
{
  bbftpd_log(LOG_DEBUG, "Authz: RETR %s", path);

#ifdef NDG_PYTHON_EMBED
  return ndg_authz_retr(path, logmessage);
#else
  return 0;
#endif
}

/**
 * Routine to authorise file store requests.
 *
 * The client is requesting the storage of a file at location \a path.
 *
 * @param path the file being stored.
 * @param logmessage pointer to a buffer of length NDG_MAX_LOGMESSAGE
 *     for storing an error message when returning -1.
 * @return 0 on success or -1 on authorisation failure.
 */
int bbftpd_private_authz_store(char *path, char *logmessage)
{
  bbftpd_log(LOG_DEBUG, "Authz: STORE %s", path);

#ifdef NDG_PYTHON_EMBED
  return ndg_authz_store(path, logmessage);
#else
  return 0;
#endif
}


/*
 * Higher level message transfer functions.
 *
 */

/**
 * Send a message of variable length to the client.
 *
 * This function sends the length of the message in a header thus the client
 * does not need to know what length message to expect.
 *
 * @param buffer a pointer to the message buffer.
 * @param length the number of bytes to send.
 * @param logmessage is filled with the error message on error.
 * @return 0 if OK, -1 if error.
 */
int ndg_message_send(char *buffer, int length, char *logmessage) {
  char ctrl[NDG_MESSAGE_LEN];

  sprintf(ctrl, "NDG-msg: %i", length);
  if (bbftpd_private_send(ctrl, NDG_MESSAGE_LEN - 1, logmessage) == -1) {
    return -1;
  }

  if (bbftpd_private_send(buffer, length, logmessage) == -1) {
    return -1;
  }

  return 0;
}

/**
 * Receive a message of variable length from the client.
 *
 * The message length is sent in a separate header.
 * The message is guaranteed to be NULL terminated.  This is done by
 * allocating length+1 bytes and filling them with \0.
 *
 * @param buffer is set to newly allocated message buffer.
 * @param length is set to the length of the message.
 * @param logmessage is filled with the logmessage on error.
 * @return 0 if OK, -1 if error.
 */
int ndg_message_recv(char **buffer, int *length, char *logmessage) {
  char ctrl[NDG_MESSAGE_LEN];

  if (bbftpd_private_recv(ctrl, NDG_MESSAGE_LEN - 1, logmessage) == -1) {
    return -1;
  }
  if (sscanf(ctrl, "NDG-msg: %i", length) != 1) {
    sprintf(logmessage, "ndg_message_recv ctrl error: %40s", ctrl);
    return -1;
  }

  if ((*buffer = (char *)calloc(*length+1, sizeof(char))) == NULL) {
    sprintf(logmessage, "ngd_message_recv malloc error");
    return -1;
  }

  if (bbftpd_private_recv(*buffer, *length, logmessage) == -1) {
    free(*buffer); *buffer = NULL;
    return -1;
  }

  return 0;
}