source: TI05-delivery/trunk/src/python_ext/bbftpd.c @ 1356

/**
 * 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.
 *
 */


#include <Python.h>
#include <ndg.h>
#include "util.h"
#include <structures.h>
#include <bbftpd_log.h>

extern char **environ;
/*
 * variables and prototypes from bbftpd source
 */

extern int be_daemon;
extern int newcontrolport;

int bbftpd_main(int argc, char **argv, char **envp);
int ndg_message_send(char *buffer, int buffertosendlength, char *logmessage) ;
int ndg_message_recv(char **buffer, int *length, char *logmessage) ;

/*
 * Static variables.
 */
static PyObject *authHandler = NULL;
static PyObject *authzHandler = NULL;

/*---------------------------------------------------------------------------------------------------
 * The following functions interact with bbftpd_private_user.  They are placed here to separate
 * python and bbftp APIs.
 *
 */


/**
 * Make a callback bbftpd->python to handle authentication.
 *
 * @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, -1 on failure
 */
int ndg_auth(char *logmessage) {

  if (authzHandler != NULL) {
    sprintf(logmessage, "ndg_auth: authzHandler already present");
    return -1;
  }
  
  if (authHandler == NULL) {
    sprintf(logmessage, "ndg_auth: no authHandler set");
    return -1;
  }

  /** @todo exceptions of type delivery.server.AuthenticationFailure should be logged as
   *      failure rather than error.
   */
  if ((authzHandler = PyObject_CallMethod(authHandler, "authenticate", NULL)) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_auth");
    return -1;
  }

  /* Authorisation is considered failed if the return value isn't True.  */
  if (!PyObject_IsTrue(authzHandler)) {
    sprintf(logmessage, "ndg_auth: python authentication failed");
    return -1;
  }

  return 0;
}

/**
 * retrieve the username from authzHandler.
 *
 * @param logmessage a pointer to a buffer of length \c NDG_MAX_LOGMESSAGE
 *     for storing an error message when returning NULL.
 * @return pointer to the username or NULL on failure
 */
char *ndg_getusername(char *logmessage) {
  char *username;
  PyObject *str_obj;

  if (authzHandler == NULL) {
    sprintf(logmessage, "bbftpd_private_auth_getusername: no authzHandler set");
    return NULL;
  }

  if ((str_obj = PyObject_GetAttrString(authzHandler, "username")) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_getusername");
    return NULL;
  }

  if ((username = PyString_AsString(str_obj)) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_getusername");
    Py_DECREF(str_obj);
    return NULL;
  }

  return username;
}


/**
 * Make a callback to do authorisation of a control command.
 *
 * @see bbftpd_private_authz_control()
 */
int ndg_authz_control(int msgcode, int transferoption, char *path, char *logmessage) {
  PyObject *ret_obj;

  if (authzHandler == NULL) {
    sprintf(logmessage, "ndg_authz_control: no authzHandler set");
    return -1;
  }
  
  if ((ret_obj = PyObject_CallMethod(authzHandler, "authzControl", "iis", msgcode, transferoption, path)) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_control");
    return -1;
  }
  
  /* Authorisation fails if ret_obj is false. */
  if (!PyObject_IsTrue(ret_obj)) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_control");
    Py_DECREF(ret_obj);
    return -1;
  }

  return 0;
}

/**
 * Make a callback to do authorisation of a retr command.
 *
 * @see bbftpd_private_authz_retr()
 */
int ndg_authz_retr(char *path, char *logmessage) {
  PyObject *ret_obj;

  if (authzHandler == NULL) {
    sprintf(logmessage, "ndg_authz_retr: no authzHandler set");
    return -1;
  }
  
  if ((ret_obj = PyObject_CallMethod(authzHandler, "authzRetr", "s", path)) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_retr");
    return -1;
  }
  
  /* Authorisation fails if ret_obj is false. */
  if (!PyObject_IsTrue(ret_obj)) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_retr");
    Py_DECREF(ret_obj);
    return -1;
  }

  return 0;
}


/**
 * Make a callback to do authorisation of a store command.
 *
 * @see bbftpd_private_authz_store()
 */
int ndg_authz_store(char *path, char *logmessage) {
  PyObject *ret_obj;

  if (authzHandler == NULL) {
    sprintf(logmessage, "ndg_authz_store: no authzHandler set");
    return -1;
  }
  
  if ((ret_obj = PyObject_CallMethod(authzHandler, "authzStore", "s", path)) == NULL) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_store");
    return -1;
  }
  
  /* Authorisation fails if ret_obj is false. */
  if (!PyObject_IsTrue(ret_obj)) {
    ndg_pyerr_to_logmessage(logmessage, "ndg_authz_store");
    Py_DECREF(ret_obj);
    return -1;
  }

  return 0;
}
 

     
/*-------------------------------------------------------------------------------------------------
 * Functions exported to python
 *
 */

/* log message to bbftpd logger */
static PyObject *pybbftpd_log(PyObject *self, PyObject *args) {
  int priority;
  char *message;

  if (!PyArg_ParseTuple(args, "is", &priority, &message)) {
    return NULL;
  }

  bbftpd_log(priority, message);

  Py_RETURN_NONE;
}

/* send(string) */
static PyObject *pybbftpd_send(PyObject *self, PyObject *args) {
  char *buffer, logmessage[1024];
  int len;

  if (!PyArg_ParseTuple(args, "s#", &buffer, &len)) {
    return NULL;
  }

  if (authHandler == NULL) {
    PyErr_SetString(PyExc_RuntimeError, "Must be called within a bbftpd callback");
    return NULL;
  }

  if (ndg_message_send(buffer, len, logmessage) == -1) {
    PyErr_SetString(PyExc_IOError, logmessage);
    return NULL;
  }

  Py_RETURN_NONE;
}

/* recv(length) -> string */
static PyObject *pybbftpd_recv(PyObject *self, PyObject *args) {
  char *buffer, logmessage[1024];
  int len;
  PyObject *ret;

  if (!PyArg_ParseTuple(args, "")) {
    return NULL;
  }

  if (authHandler == NULL) {
    PyErr_SetString(PyExc_RuntimeError, "Must be called within a bbftpd callback");
    return NULL;
  }

  if (ndg_message_recv(&buffer, &len, logmessage) == -1) {
    PyErr_SetString(PyExc_IOError, logmessage);
    free(buffer);
    return NULL;
  }

  ret = Py_BuildValue("s#", buffer, len);
  free(buffer);

  return ret;
}



/**
 * Main entry point for the python module.
 */
static PyObject *pybbftpd_run(PyObject *self, PyObject *args) {
  int argc, i;
  char **argv, **arg_p, *p;
  int pid;
  char preargs[2][20] = { "bbftpd_embedded", "-b" };
  PyObject *daemon_args, *item;

  if (!PyArg_ParseTuple(args, "OO", &authHandler, &daemon_args)) {
    return NULL;
  }
  Py_INCREF(authHandler);
  Py_INCREF(daemon_args);

  /*
   * Convert arguments into a standard argv sequence.
   */
  argc = PySequence_Size(daemon_args);
  if ((argv = (char**)malloc((argc + 2)*sizeof(char*))) == NULL) {
    PyErr_SetString(PyExc_MemoryError, "malloc failed");
    Py_DECREF(daemon_args);
    return NULL;
  }

  // Add fixed arguments to daemon's argv
  arg_p = argv;
  *arg_p = preargs[0]; arg_p++;
  *arg_p = preargs[1]; arg_p++;

  for (i=0; i<argc; i++) {
    if ((item = PySequence_GetItem(daemon_args, i)) == NULL) {
      free(argv);
      Py_DECREF(authHandler);
      Py_DECREF(daemon_args);
      return NULL;
    }
    if ((p = PyString_AsString(item)) == NULL) {
      free(argv);
      Py_DECREF(item);
      Py_DECREF(authHandler);
      Py_DECREF(daemon_args);
      return NULL;
    }
    if ((*arg_p = (char *)malloc(strlen(p))) == NULL) {
      Py_DECREF(item);
      Py_DECREF(authHandler);
      Py_DECREF(daemon_args);
      PyErr_SetString(PyExc_MemoryError, "malloc failed");
      return NULL;
    }
    strcpy(*arg_p, p);

    arg_p++;
    Py_DECREF(item);
  }

  /*
   * We must reset some global variables so that bbftpd_run can be executed multiple times.
   */
  be_daemon = 0;

  pid = bbftpd_main(argc+2, argv, environ);

  free(argv);
  Py_DECREF(authHandler); authHandler = NULL;
  Py_DECREF(daemon_args);

  return Py_BuildValue("i", pid);
}

static PyMethodDef BbftpdMethods[] = {
  {
    "run", pybbftpd_run, METH_VARARGS, 
    "Execute the bbftpd server.\n"
    "\n"
    "Forks an embedded bbftpd process as if it were executed\n"
    "with the command line $ bbftpd -b <args>."
    "\n"
    "@param args: command line arguments to pass to the server\n"
    "@return: the PID of the server process\n"
  },
  {
    "send", pybbftpd_send, METH_VARARGS,
    "Send an authentication message to the client.\n"
    "\n"
    "Equivilent to bbftpd_private_send() C call.\n"
    "\n"
    "@param buffer: A string containing the message\n"
    "@raise IOError: if bbftpd_private_send() call fails\n"
  },
  {
    "recv", pybbftpd_recv, METH_VARARGS,
    "Receive an authentication message from the client.\n"
    "\n"
    "Equivilent to bbftpd_private_recv() C call.\n"
    "\n"
    "@param len: The length of message to expect\n"
    "@return: A string containing the message\n"
    "@raise IOError: if bbftpd_private_recv() call fails\n"
  },
  {
    "log", pybbftpd_log, METH_VARARGS,
    "Send a message to the bbftpd logger.\n"
    "\n"
    "@param priority: as syslog priority\n"
    "@param message: A string containing the message to send\n"
  },
  {NULL, NULL, 0, NULL}
};


#define ADDCONST(m,x) PyModule_AddIntConstant(m, #x, x)

PyMODINIT_FUNC initbbftpd(void) {
  PyObject *mod;

  mod = Py_InitModule("bbftpd", BbftpdMethods);

  ADDCONST(mod, MSG_CHDIR_V2);
  ADDCONST(mod, MSG_CHDIR_V2);
  ADDCONST(mod, MSG_LIST_V2);
  ADDCONST(mod, MSG_MKDIR_V2);
  ADDCONST(mod, MSG_RM);
  ADDCONST(mod, MSG_STAT);
  ADDCONST(mod, MSG_DF);
  
  ADDCONST(mod, TROPT_TMP);
  ADDCONST(mod, TROPT_ACC);
  ADDCONST(mod, TROPT_MODE);
  ADDCONST(mod, TROPT_DIR);
  ADDCONST(mod, TROPT_GZIP);
  ADDCONST(mod, TROPT_RFIO);
  ADDCONST(mod, TROPT_RFIO_O);
  ADDCONST(mod, TROPT_QBSS);
  
}