Merge branch 'maint'
authorAndre Noll <maan@systemlinux.org>
Mon, 9 Nov 2009 17:31:01 +0000 (18:31 +0100)
committerAndre Noll <maan@systemlinux.org>
Mon, 9 Nov 2009 17:31:01 +0000 (18:31 +0100)
1  2 
alsa_write.c
blob.c
fecdec_filter.c

diff --combined alsa_write.c
@@@ -12,7 -12,6 +12,7 @@@
   * based on the vplay program by Michael Beck.
   */
  
 +#include <regex.h>
  #include <sys/types.h>
  #include <dirent.h>
  #include <alsa/asoundlib.h>
@@@ -80,18 -79,19 +80,19 @@@ static int alsa_init(struct private_als
                        pad->channels) < 0)
                return -E_CHANNEL_COUNT;
        if (snd_pcm_hw_params_set_rate_near(pad->handle, hwparams,
-                       &pad->samplerate, 0) < 0)
+                       &pad->samplerate, NULL) < 0)
                return -E_SET_RATE;
-       err = snd_pcm_hw_params_get_buffer_time_max(hwparams, &pad->buffer_time, 0);
+       err = snd_pcm_hw_params_get_buffer_time_max(hwparams,
+               &pad->buffer_time, NULL);
        if (err < 0 || !pad->buffer_time)
                return -E_GET_BUFFER_TIME;
        PARA_INFO_LOG("buffer time: %d\n", pad->buffer_time);
        if (snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams,
-                       &pad->buffer_time, 0) < 0)
+                       &pad->buffer_time, NULL) < 0)
                return -E_SET_BUFFER_TIME;
        if (snd_pcm_hw_params(pad->handle, hwparams) < 0)
                return -E_HW_PARAMS;
-       snd_pcm_hw_params_get_period_size(hwparams, &period_size, 0);
+       snd_pcm_hw_params_get_period_size(hwparams, &period_size, NULL);
        snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
        PARA_INFO_LOG("buffer size: %lu, period_size: %lu\n", buffer_size,
                period_size);
diff --combined blob.c
--- 1/blob.c
--- 2/blob.c
+++ b/blob.c
@@@ -6,42 -6,14 +6,42 @@@
  
  /** \file blob.c Macros and functions for blob handling. */
  
 +#include <regex.h>
  #include <fnmatch.h>
 +#include <openssl/rc4.h>
 +#include <osl.h>
 +
  #include "para.h"
  #include "error.h"
 +#include "crypt.h"
  #include "string.h"
  #include "afh.h"
  #include "afs.h"
  #include "net.h"
  #include "ipc.h"
 +#include "portable_io.h"
 +
 +/**
 + * Compare two osl objects pointing to unsigned integers of 32 bit size.
 + *
 + * \param obj1 Pointer to the first integer.
 + * \param obj2 Pointer to the second integer.
 + *
 + * \return The values required for an osl compare function.
 + *
 + * \sa osl_compare_func, osl_hash_compare().
 + */
 +static int uint32_compare(const struct osl_object *obj1, const struct osl_object *obj2)
 +{
 +      uint32_t d1 = read_u32((const char *)obj1->data);
 +      uint32_t d2 = read_u32((const char *)obj2->data);
 +
 +      if (d1 < d2)
 +              return 1;
 +      if (d1 > d2)
 +              return -1;
 +      return 0;
 +}
  
  static struct osl_column_description blob_cols[] = {
        [BLOBCOL_ID] = {
        }
  };
  
 +/** Define an osl table description for a blob table. */
 +#define DEFINE_BLOB_TABLE_DESC(table_name) \
 +      struct osl_table_description table_name ## _table_desc = { \
 +              .name = #table_name, \
 +              .num_columns = NUM_BLOB_COLUMNS, \
 +              .flags = OSL_LARGE_TABLE, \
 +              .column_descriptions = blob_cols \
 +      };
 +
 +/** Define a pointer to an osl blob table with a canonical name. */
 +#define DEFINE_BLOB_TABLE_PTR(table_name) struct osl_table *table_name ## _table;
 +
 +
 +/** Define a blob table. */
 +#define INIT_BLOB_TABLE(table_name) \
 +      DEFINE_BLOB_TABLE_DESC(table_name); \
 +      DEFINE_BLOB_TABLE_PTR(table_name);
 +
  /** \cond doxygen isn't smart enough to recognize these */
  INIT_BLOB_TABLE(lyrics);
  INIT_BLOB_TABLE(images);
@@@ -117,7 -71,7 +117,7 @@@ static int print_blob(struct osl_table 
  
        if (!(lbad->flags & BLOB_LS_FLAG_LONG))
                return para_printf(&lbad->pb, "%s\n", name);
 -      ret = osl_get_object(table, row, BLOBCOL_ID, &obj);
 +      ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
        if (ret < 0) {
                para_printf(&lbad->pb, "%s: %s\n", name, para_strerror(-ret));
                return ret;
@@@ -162,7 -116,7 +162,7 @@@ static void com_lsblob_callback(struct 
        free(lbad.pb.buf);
  }
  
 -static int com_lsblob(callback_function *f, int fd, int argc, char * const * const argv)
 +static int com_lsblob(callback_function *f, struct rc4_context *rc4c, int argc, char * const * const argv)
  {
        uint32_t flags = 0;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
  //    if (argc > i)
  //            return -E_BLOB_SYNTAX;
        return send_option_arg_callback_request(&options, argc - i,
 -              argv + i, f, send_result, &fd);
 +              argv + i, f, rc4_send_result, rc4c);
  }
  
  static int cat_blob(struct osl_table *table, struct osl_row *row,
        int ret = 0, ret2;
        struct osl_object obj;
  
 -      ret = osl_open_disk_object(table, row, BLOBCOL_DEF, &obj);
 +      ret = osl(osl_open_disk_object(table, row, BLOBCOL_DEF, &obj));
        if (ret < 0)
                return ret;
        if (obj.size)
                ret = pass_buffer_as_shm(obj.data, obj.size, data);
 -      ret2 = osl_close_disk_object(&obj);
 +      ret2 = osl(osl_close_disk_object(&obj));
        return (ret < 0)? ret : ret2;
  }
  
@@@ -226,13 -180,12 +226,13 @@@ static void com_catblob_callback(struc
        for_each_matching_row(&pmd);
  }
  
 -static int com_catblob(callback_function *f, int fd, int argc,
 +static int com_catblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
  {
        if (argc < 2)
                return -E_BLOB_SYNTAX;
 -      return send_standard_callback_request(argc - 1, argv + 1, f, send_result, &fd);
 +      return send_standard_callback_request(argc - 1, argv + 1, f,
 +              rc4_send_result, rc4c);
  }
  
  /** Used for removing rows from a blob table. */
@@@ -247,7 -200,7 +247,7 @@@ static int remove_blob(struct osl_tabl
                const char *name, void *data)
  {
        struct rmblob_data *rmbd = data;
 -      int ret = osl_del_row(table, row);
 +      int ret = osl(osl_del_row(table, row));
        if (ret < 0) {
                para_printf(&rmbd->pb, "%s: %s\n", name, para_strerror(-ret));
                return ret;
@@@ -295,13 -248,13 +295,13 @@@ out
        free(rmbd.pb.buf);
  }
  
 -static int com_rmblob(callback_function *f, int fd, int argc,
 +static int com_rmblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
  {
        if (argc < 2)
                return -E_MOOD_SYNTAX;
        return send_option_arg_callback_request(NULL, argc - 1, argv + 1, f,
 -              send_result, &fd);
 +              rc4_send_result, rc4c);
  }
  
  static void com_addblob_callback(struct osl_table *table, __a_unused int fd,
        unsigned num_rows;
        int ret;
  
 -      ret = osl_get_num_rows(table, &num_rows);
 +      ret = osl(osl_get_num_rows(table, &num_rows));
        if (ret < 0)
                goto out;
        if (!num_rows) { /* this is the first entry ever added */
                objs[BLOBCOL_NAME].size = 1;
                objs[BLOBCOL_DEF].data = "";
                objs[BLOBCOL_DEF].size = 1;
 -              ret = osl_add_row(table, objs);
 +              ret = osl(osl_add_row(table, objs));
                if (ret < 0)
                        goto out;
        } else {
                /* check if name already exists */
                struct osl_row *row;
                struct osl_object obj = {.data = name, .size = name_len};
 -              ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
 -              if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND)
 +              ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
 +              if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
                        goto out;
                if (ret >= 0) { /* we already have a blob with this name */
                        obj.data = name + name_len;
                        obj.size = query->size - name_len;
 -                      ret = osl_update_object(table, row, BLOBCOL_DEF, &obj);
 +                      ret = osl(osl_update_object(table, row, BLOBCOL_DEF, &obj));
                        goto out;
                }
                /* new blob, get id of the dummy row and increment it */
                obj.data = "";
                obj.size = 1;
 -              ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
 +              ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
                if (ret < 0)
                        goto out;
 -              ret = osl_get_object(table, row, BLOBCOL_ID, &obj);
 +              ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
                if (ret < 0)
                        goto out;
                id = *(uint32_t *)obj.data + 1;
                obj.data = &id;
 -              ret = osl_update_object(table, row, BLOBCOL_ID, &obj);
 +              ret = osl(osl_update_object(table, row, BLOBCOL_ID, &obj));
                if (ret < 0)
                        goto out;
        }
        objs[BLOBCOL_NAME].size = name_len;
        objs[BLOBCOL_DEF].data = name + name_len;
        objs[BLOBCOL_DEF].size = query->size - name_len;
 -      ret = osl_add_row(table, objs);
 +      ret = osl(osl_add_row(table, objs));
        if (ret < 0)
                goto out;
        afs_event(BLOB_ADD, NULL, table);
@@@ -373,82 -326,7 +373,82 @@@ out
                PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
  }
  
 -static int com_addblob(callback_function *f, int fd, int argc,
 +/*
 + * write input from fd to dynamically allocated buffer,
 + * but maximal max_size byte.
 + */
 +static int fd2buf(struct rc4_context *rc4c, unsigned max_size, struct osl_object *obj)
 +{
 +      const size_t chunk_size = 1024;
 +      size_t size = 2048, received = 0;
 +      int ret;
 +      char *buf = para_malloc(size);
 +
 +      for (;;) {
 +              ret = rc4_recv_bin_buffer(rc4c, buf + received, chunk_size);
 +              if (ret <= 0)
 +                      break;
 +              received += ret;
 +              if (received + chunk_size >= size) {
 +                      size *= 2;
 +                      ret = -E_INPUT_TOO_LARGE;
 +                      if (size > max_size)
 +                              break;
 +                      buf = para_realloc(buf, size);
 +              }
 +      }
 +      obj->data = buf;
 +      obj->size = received;
 +      if (ret < 0)
 +              free(buf);
 +      return ret;
 +}
 +
 +/*
 + * Read data from a file descriptor, and send it to the afs process.
 + *
 + * \param rc4c crypt context containing the file descriptor to read data from.
 + * \param arg_obj Pointer to the arguments to \a f.
 + * \param f The callback function.
 + * \param max_len Don't read more than that many bytes from stdin.
 + * \param result_handler See \ref send_callback_request.
 + * \param private_result_data See \ref send_callback_request.
 + *
 + * This function is used by commands that wish to let para_server store
 + * arbitrary data specified by the user (for instance the add_blob family of
 + * commands). First, at most \a max_len bytes are read and decrypted from the
 + * file descriptor given by \a rc4c. The result is concatenated with the buffer
 + * given by \a arg_obj, and the combined buffer is made available to the afs
 + * process via the callback method. See \ref send_callback_request for details.
 + *
 + * \return Negative on errors, the return value of the underlying call to
 + * send_callback_request() otherwise.
 + */
 +static int stdin_command(struct rc4_context *rc4c, struct osl_object *arg_obj,
 +              callback_function *f, unsigned max_len,
 +              callback_result_handler *result_handler,
 +              void *private_result_data)
 +{
 +      struct osl_object query, stdin_obj;
 +      int ret;
 +
 +      ret = rc4_send_buffer(rc4c, AWAITING_DATA_MSG);
 +      if (ret < 0)
 +              return ret;
 +      ret = fd2buf(rc4c, max_len, &stdin_obj);
 +      if (ret < 0)
 +              return ret;
 +      query.size = arg_obj->size + stdin_obj.size;
 +      query.data = para_malloc(query.size);
 +      memcpy(query.data, arg_obj->data, arg_obj->size);
 +      memcpy((char *)query.data + arg_obj->size, stdin_obj.data, stdin_obj.size);
 +      free(stdin_obj.data);
 +      ret = send_callback_request(f, &query, result_handler, private_result_data);
 +      free(query.data);
 +      return ret;
 +}
 +
 +static int com_addblob(callback_function *f, struct rc4_context *rc4c, int argc,
                char * const * const argv)
  {
        struct osl_object arg_obj;
                return -E_BLOB_SYNTAX;
        arg_obj.size = strlen(argv[1]) + 1;
        arg_obj.data = (char *)argv[1];
 -      return stdin_command(fd, &arg_obj, f, 10 * 1024 * 1024, NULL, NULL);
 +      return stdin_command(rc4c, &arg_obj, f, 10 * 1024 * 1024, NULL, NULL);
  }
  
  /* FIXME: Print output to client, not to log file */
@@@ -470,13 -348,13 +470,13 @@@ static void com_mvblob_callback(struct 
        struct osl_object obj = {.data = src, .size = strlen(src) + 1};
        char *dest = src + obj.size;
        struct osl_row *row;
 -      int ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
 +      int ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
  
        if (ret < 0)
                goto out;
        obj.data = dest;
        obj.size = strlen(dest) + 1;
 -      ret = osl_update_object(table, row, BLOBCOL_NAME, &obj);
 +      ret = osl(osl_update_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                goto out;
        afs_event(BLOB_RENAME, NULL, table);
@@@ -485,7 -363,7 +485,7 @@@ out
                PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
  }
  
 -static int com_mvblob(callback_function *f, __a_unused int fd,
 +static int com_mvblob(callback_function *f, __a_unused struct rc4_context *rc4c,
                int argc, char * const * const argv)
  {
        if (argc != 3)
        { \
                return com_ ## cmd_name ## blob_callback(table_name ## _table, fd, query); \
        } \
 -      int com_ ## cmd_name ## cmd_prefix(int fd, int argc, char * const * const argv) \
 +      int com_ ## cmd_name ## cmd_prefix(struct rc4_context *rc4c, int argc, char * const * const argv) \
        { \
 -              return com_ ## cmd_name ## blob(com_ ## cmd_name ## cmd_prefix ## _callback, fd, argc, argv); \
 +              return com_ ## cmd_name ## blob(com_ ## cmd_name ## cmd_prefix ## _callback, rc4c, argc, argv); \
        }
  
  static int blob_get_name_by_id(struct osl_table *table, uint32_t id,
        *name = NULL;
        if (!id)
                return 1;
 -      ret = osl_get_row(table, BLOBCOL_ID, &obj, &row);
 +      ret = osl(osl_get_row(table, BLOBCOL_ID, &obj, &row));
        if (ret < 0)
                return ret;
 -      ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
 +      ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                return ret;
        *name = (char *)obj.data;
@@@ -542,10 -420,10 +542,10 @@@ static int blob_get_def_by_name(struct 
        def->data = NULL;
        if (!*name)
                return 1;
 -      ret = osl_get_row(table, BLOBCOL_NAME, &obj, &row);
 +      ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
        if (ret < 0)
                return ret;
 -      return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
 +      return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
  }
  
  /** Define the \p get_def_by_id function for this blob type. */
@@@ -565,10 -443,10 +565,10 @@@ static int blob_get_def_by_id(struct os
        def->data = NULL;
        if (!id)
                return 1;
 -      ret = osl_get_row(table, BLOBCOL_ID, &obj, &row);
 +      ret = osl(osl_get_row(table, BLOBCOL_ID, &obj, &row));
        if (ret < 0)
                return ret;
 -      return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
 +      return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
  }
  
  /** Define the \p get_def_by_id function for this blob type. */
@@@ -582,11 -460,11 +582,11 @@@ static int blob_get_name_and_def_by_row
                const struct osl_row *row, char **name, struct osl_object *def)
  {
        struct osl_object obj;
 -      int ret = osl_get_object(table, row, BLOBCOL_NAME, &obj);
 +      int ret = osl(osl_get_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0)
                return ret;
        *name = obj.data;
 -      return osl_open_disk_object(table, row, BLOBCOL_DEF, def);
 +      return osl(osl_open_disk_object(table, row, BLOBCOL_DEF, def));
  }
  /** Define the \p get_name_and_def_by_row function for this blob type. */
  #define DEFINE_GET_NAME_AND_DEF_BY_ROW(table_name, cmd_prefix) \
  
  /** Define the \p close function for this blob type. */
  #define DEFINE_BLOB_CLOSE(table_name) \
-       void table_name ## _close(void) \
+       static void table_name ## _close(void) \
        { \
                osl_close_table(table_name ## _table, OSL_MARK_CLEAN); \
                table_name ## _table = NULL; \
  
  /** Define the \p create function for this blob type. */
  #define DEFINE_BLOB_CREATE(table_name) \
-       int table_name ## _create(const char *dir) \
+       static int table_name ## _create(const char *dir) \
        { \
                table_name ## _table_desc.dir = dir; \
                return osl_create_table(&table_name ## _table_desc); \
@@@ -619,17 -497,17 +619,17 @@@ static int blob_open(struct osl_table *
  {
        int ret;
        desc->dir = dir;
 -      ret = osl_open_table(desc, table);
 +      ret = osl(osl_open_table(desc, table));
        if (ret >= 0)
                return ret;
        *table = NULL;
 -      if (ret >= 0 || is_errno(-ret, ENOENT))
 +      if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
                return 1;
        return ret;
  }
  
  #define DEFINE_BLOB_OPEN(table_name) \
-       int table_name ## _open(const char *dir) \
+       static int table_name ## _open(const char *dir) \
        { \
                return blob_open(&table_name ## _table, \
                        &table_name ## _table_desc, dir); \
diff --combined fecdec_filter.c
@@@ -6,8 -6,6 +6,8 @@@
  
  /** \file fecdec_filter.c A filter that fec-decodes an audio stream. */
  
 +#include <regex.h>
 +
  #include <dirent.h>
  #include "para.h"
  #include "error.h"
@@@ -104,7 -102,7 +104,7 @@@ struct private_fecdec_data 
  
  /** Iterate over all fecdec groups. */
  #define FOR_EACH_FECDEC_GROUP(g, d) for (g = (d)->groups; \
-       (g) - (d)->groups < NUM_FEC_GROUPS; (g)++)
+       (g) < (d)->groups + NUM_FEC_GROUPS; (g)++)
  
  static int group_complete(struct fecdec_group *fg)
  {