lib/perl/Blerg-Database/Database.xs

   1 #include "EXTERN.h"
   2 #include "perl.h"
   3 #include "XSUB.h"
   4
   5 #include "ppport.h"
   6
   7 #include "config.h"
   8 #include "database/database.h"
   9 #include "database/blergref.h"
  10 #include "database/tags.h"
  11 #include "database/subscription.h"
  12 #include "database/util.h"
  13 #include "common/auth.h"
  14
  15 #include "const-c.inc"
  16
  17 HV * blergref_to_perl_hash(struct blergref *list) {
  18         HV *tmp;
  19         char buf[21];
  20         int n;
  21
  22         tmp = newHV();
  23         hv_store(tmp, "author", 6, newSVpv(list->author, 0), 0);
  24         n = snprintf(buf, 21, "%llu", list->record);
  25         hv_store(tmp, "record", 6, newSVpv(buf, n), 0);
  26
  27         return tmp;
  28 }
  29
  30 MODULE = Blerg::Database                PACKAGE = Blerg::Database
  31
  32 INCLUDE: const-xs.inc
  33 PROTOTYPES: ENABLE
  34
  35 int exists(const char *name)
  36     CODE:
  37         RETVAL = blerg_exists(name);
  38     OUTPUT:
  39         RETVAL
  40
  41 struct blerg * _open(const char *name)
  42     CODE:
  43         RETVAL = blerg_open(name);
  44     OUTPUT:
  45         RETVAL
  46
  47 int _close(struct blerg *ptr)
  48     CODE:
  49         RETVAL = blerg_close(ptr);
  50     OUTPUT:
  51         RETVAL
  52
  53 const char * _store(struct blerg *ptr, const char *data, int length(data))
  54     PROTOTYPE: $$
  55     INIT:
  56         uint64_t record;
  57         char buf[21];
  58         int n;
  59     PPCODE:
  60         record = blerg_store(ptr, data, XSauto_length_of_data);
  61         n = snprintf(buf, 21, "%llu", record);
  62         XPUSHs(sv_2mortal(newSVpv(buf, n)));
  63
  64 const char * _fetch(struct blerg *ptr, const char *str_record)
  65     INIT:
  66         uint64_t record;
  67         char *buf;
  68         int buflen;
  69         int n;
  70     PPCODE:
  71         record = strtoull(str_record, NULL, 0);
  72         n = blerg_fetch(ptr, record, &buf, &buflen);
  73         if (!n) {
  74             XSRETURN_UNDEF;
  75         }
  76         XPUSHs(sv_2mortal(newSVpvn(buf, buflen)));
  77         free(buf);
  78
  79 const char * _get_record_count(struct blerg *ptr)
  80     INIT:
  81         uint64_t count;
  82         char buf[21];
  83         int n;
  84     PPCODE:
  85         count = blerg_get_record_count(ptr);
  86         n = snprintf(buf, 21, "%llu", count);
  87         XPUSHs(sv_2mortal(newSVpv(buf, n)));
  88
  89 time_t _get_timestamp(struct blerg *ptr, const char *str_record)
  90     INIT:
  91         uint64_t record;
  92     CODE:
  93         record = strtoull(str_record, NULL, 0);
  94         RETVAL = blerg_get_timestamp(ptr, record);
  95     OUTPUT:
  96         RETVAL
  97
  98 int _set_subscription_mark(struct blerg *ptr)
  99     CODE:
 100         RETVAL = blerg_set_subscription_mark(ptr);
 101     OUTPUT:
 102         RETVAL
 103
 104 const char * _get_subscription_mark(struct blerg *ptr)
 105     INIT:
 106         uint64_t mark;
 107         char buf[21];
 108         int n;
 109     PPCODE:
 110         mark = blerg_get_subscription_mark(ptr);
 111         n = snprintf(buf, 21, "%llu", mark);
 112         XPUSHs(sv_2mortal(newSVpv(buf, n)));
 113
 114 int _set_mute(struct blerg *ptr, int v)
 115     CODE:
 116         RETVAL = blerg_set_mute(ptr, v);
 117     OUTPUT:
 118         RETVAL
 119
 120 int _get_mute(struct blerg *ptr)
 121     CODE:
 122         RETVAL = blerg_get_mute(ptr);
 123     OUTPUT:
 124         RETVAL
 125
 126 void tag_list(const char *tag, const char *str_offset, int direction)
 127     INIT:
 128         HV * tmp;
 129         struct blergref *list;
 130         uint64_t offset;
 131         int count, i;
 132     PPCODE:
 133         offset = strtoull(str_offset, NULL, 0);
 134         count = 50;
 135         list = tag_list(tag, offset, &count, direction);
 136         if (list == NULL) {
 137             XSRETURN_EMPTY;
 138         }
 139
 140         i = count - 1;
 141         while (i >= 0) {
 142             tmp = blergref_to_perl_hash(&list[i]);
 143             XPUSHs(sv_2mortal(newRV_noinc((SV*)tmp)));
 144             i--;
 145         }
 146         free(list);
 147
 148 int subscription_add(const char *from, const char *to)
 149
 150 int subscription_remove(const char *from, const char *to)
 151
 152 void _subscription_list(const char *author, const char *str_offset, int direction)
 153     INIT:
 154         HV *tmp;
 155         struct blergref *list;
 156         uint64_t offset;
 157         int count, i;
 158     PPCODE:
 159         offset = strtoull(str_offset, NULL, 0);
 160         count = 50;
 161         list = subscription_list(author, offset, &count, direction);
 162         if (list == NULL) {
 163             XSRETURN_EMPTY;
 164         }
 165
 166         i = count - 1;
 167         while (i >= 0) {
 168             tmp = blergref_to_perl_hash(&list[i]);
 169             XPUSHs(sv_2mortal(newRV_noinc((SV*)tmp)));
 170             i--;
 171         }
 172         free(list);
 173
 174 int valid_tag_name(const char *name)
 175
 176 int valid_name(const char *name)
 177
 178 int auth_set_password(const char *username, const char *password)
 179
 180 int auth_check_password(const char *username, const char *password)
 181
 182 char * auth_login(const char *username, const char *password)
 183     INIT:
 184         char *token;
 185     PPCODE:
 186         token = auth_login(username, password);
 187         if (token != NULL) {
 188             XPUSHs(sv_2mortal(newSVpv(token, TOKEN_SIZE * 2)));
 189         } else {
 190             XSRETURN_UNDEF;
 191         }
 192         free(token);
 193
 194 int auth_logout(const char *username, const char *token)
 195
 196 int auth_check_token(const char *username, const char *given_token)