submit/commands.c

   1 /*
   2  *  The Submit Daemon: High-Level Part of the Protocol
   3  *
   4  *  (c) 2007 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include "lib/lib.h"
   8 #include "lib/mempool.h"
   9 #include "lib/simple-lists.h"
  10 #include "lib/stkstring.h"
  11 #include "sherlock/object.h"
  12 #include "sherlock/objread.h"
  13
  14 #include <time.h>
  15
  16 #include "submitd.h"
  17
  18 /*** REQUESTS AND REPLIES ***/
  19
  20 static void NONRET
  21 read_error_cb(struct obj_read_state *st UNUSED, char *msg)
  22 {
  23   client_error("Request parse error: %s", msg);
  24 }
  25
  26 static int
  27 read_request(struct conn *c)
  28 {
  29   if (c->pool)
  30     mp_flush(c->pool);
  31   else
  32     c->pool = mp_new(1024);
  33   c->request = obj_new(c->pool);
  34   c->reply = obj_new(c->pool);
  35
  36   struct obj_read_state st;
  37   obj_read_start(&st, c->request);
  38   st.error_callback = read_error_cb;
  39   byte line[1024];
  40   uns size = 0;
  41   for (;;)
  42     {
  43       int l = bgets_nodie(&c->rx_fb, line, sizeof(line));
  44       if (l < 0)
  45         client_error("Request line too long");
  46       if (!l)
  47         {
  48           if (!size)
  49             return 0;
  50           else
  51             client_error("Truncated request");
  52         }
  53       if (l == 1)
  54         break;
  55       size += l;
  56       if (size >= max_request_size)
  57         client_error("Request too long");
  58       obj_read_attr(&st, line[0], line+1);
  59     }
  60   obj_read_end(&st);
  61   return 1;
  62 }
  63
  64 static void
  65 write_reply(struct conn *c)
  66 {
  67   if (!obj_find_attr(c->reply, '-') && !obj_find_attr(c->reply, '+'))
  68     obj_set_attr(c->reply, '+', "OK");
  69   if (trace_commands)
  70     {
  71       byte *m;
  72       if (m = obj_find_aval(c->reply, '-'))
  73         msg(L_DEBUG, ">> -%s", m);
  74       else if (m = obj_find_aval(c->reply, '+'))
  75         msg(L_DEBUG, ">> +%s", m);
  76       else
  77         msg(L_DEBUG, ">> ???");
  78     }
  79   obj_write(&c->tx_fb, c->reply, BUCKET_TYPE_PLAIN);
  80   bputc(&c->tx_fb, '\n');
  81   bflush(&c->tx_fb);
  82 }
  83
  84 static void
  85 err(struct conn *c, byte *msg)
  86 {
  87   obj_set_attr(c->reply, '-', msg);
  88 }
  89
  90 /*** STATUS ***/
  91
  92 static void
  93 copy_attrs(struct odes *dest, struct odes *src)
  94 {
  95   for (struct oattr *a = src->attrs ; a; a=a->next)
  96     if (a->attr < OBJ_ATTR_SON)
  97       for (struct oattr *aa = a; aa; aa=aa->same)
  98         obj_add_attr(dest, aa->attr, aa->val);
  99 }
 100
 101 static void
 102 cmd_status(struct conn *c)
 103 {
 104   uns verbose = obj_find_anum(c->request, 'V', 0);
 105   task_load_status(c);
 106
 107   CLIST_FOR_EACH(struct task *, t, task_list)
 108     {
 109       struct odes *to = task_status_find_task(c, t, 1);
 110       struct odes *tr = obj_add_son(c->reply, 'T' + OBJ_ATTR_SON);
 111       copy_attrs(tr, to);
 112       CLIST_FOR_EACH(simp_node *, x, *t->extensions)
 113         obj_add_attr(tr, 'A', x->s);
 114       CLIST_FOR_EACH(simp_node *, p, t->parts)
 115         {
 116           struct odes *po = task_status_find_part(to, p->s, 1);
 117           struct odes *pr = obj_add_son(tr, 'P' + OBJ_ATTR_SON);
 118           copy_attrs(pr, po);
 119           uns current_ver = obj_find_anum(po, 'V', 0);
 120           for (struct oattr *v = obj_find_attr(po, 'V' + OBJ_ATTR_SON); v; v=v->same)
 121             {
 122               struct odes *vo = v->son;
 123               uns ver = obj_find_anum(vo, 'V', 0);
 124               if (ver == current_ver || verbose)
 125                 obj_add_son_ref(pr, 'V' + OBJ_ATTR_SON, vo);
 126             }
 127         }
 128     }
 129 }
 130
 131 /*** SUBMIT ***/
 132
 133 static struct fastbuf *
 134 read_attachment(struct conn *c)
 135 {
 136   uns size = obj_find_anum(c->request, 'S', 0);
 137   if (size > max_attachment_size)
 138     {
 139       err(c, "Submission too large");
 140       return NULL;
 141     }
 142   obj_set_attr(c->reply, '+', "Go on");
 143   write_reply(c);
 144   obj_set_attr(c->reply, '+', NULL);
 145
 146   // This is less efficient than bbcopy(), but we want our own error handling.
 147   struct fastbuf *fb = bopen_tmp(4096);
 148   byte buf[4096];
 149   uns remains = size;
 150   while (remains)
 151     {
 152       uns cnt = bread(&c->rx_fb, buf, MIN(remains, (uns)sizeof(buf)));
 153       if (!cnt)
 154         {
 155           bclose(fb);
 156           client_error("Truncated attachment");
 157         }
 158       bwrite(fb, buf, cnt);
 159       remains -= cnt;
 160     }
 161   brewind(fb);
 162   return fb;
 163 }
 164
 165 static void
 166 cmd_submit(struct conn *c)
 167 {
 168   byte *tname = obj_find_aval(c->request, 'T');
 169   if (!tname)
 170     {
 171       err(c, "No task specified");
 172       return;
 173     }
 174   struct task *task = task_find(tname);
 175   if (!task)
 176     {
 177       err(c, "No such task");
 178       return;
 179     }
 180
 181   byte *pname = obj_find_aval(c->request, 'P');
 182   if (!pname)
 183     {
 184       simp_node *s = clist_head(&task->parts);
 185       ASSERT(s);
 186       pname = s->s;
 187     }
 188   else if (!part_exists_p(task, pname))
 189     {
 190       err(c, "No such task part");
 191       return;
 192     }
 193
 194   byte *ext = obj_find_aval(c->request, 'X');
 195   if (!ext || !ext_exists_p(task, ext))
 196     {
 197       err(c, "Missing or invalid extension");
 198       return;
 199     }
 200
 201   struct fastbuf *fb = read_attachment(c);
 202   if (!fb)
 203     return;
 204
 205   task_lock_status(c);
 206   struct odes *tasko = task_status_find_task(c, task, 1);
 207   struct odes *parto = task_status_find_part(tasko, pname, 1);
 208   uns current_ver = obj_find_anum(parto, 'V', 0);
 209   uns last_ver = 0;
 210   uns replaced_ver = 0;
 211   for (struct oattr *a = obj_find_attr(parto, 'V' + OBJ_ATTR_SON); a; a=a->same)
 212     {
 213       uns ver = obj_find_anum(a->son, 'V', 0);
 214       byte *ext = obj_find_aval(a->son, 'X');
 215       ASSERT(ver && ext);
 216       last_ver = MAX(last_ver, ver);
 217       if (ver == current_ver)
 218         {
 219           task_delete_part(c->user, tname, pname, ext, ver);
 220           obj_set_attr(a->son, 'S', "replaced");
 221           replaced_ver = current_ver;
 222         }
 223     }
 224   struct odes *vero = obj_add_son(parto, 'V' + OBJ_ATTR_SON);
 225   obj_set_attr_num(vero, 'V', ++last_ver);
 226   obj_set_attr_num(vero, 'T', time(NULL));
 227   obj_set_attr_num(vero, 'L', obj_find_anum(c->request, 'S', 0));
 228   obj_set_attr(vero, 'S', "submitted");
 229   obj_set_attr(vero, 'X', ext);
 230   task_submit_part(c->user, tname, pname, ext, last_ver, fb);
 231   obj_set_attr_num(parto, 'V', last_ver);
 232   task_unlock_status(c, 1);
 233
 234   msg(L_INFO, "User %s submitted task %s%s (version %d%s)",
 235         c->user, tname,
 236         (strcmp(tname, pname) ? stk_printf("/%s", pname) : ""),
 237         last_ver,
 238         (replaced_ver ? stk_printf(", replaced %d", replaced_ver) : ""));
 239 }
 240
 241 /*** COMMAND MUX ***/
 242
 243 static void
 244 execute_command(struct conn *c)
 245 {
 246   byte *cmd = obj_find_aval(c->request, '!');
 247   if (!cmd)
 248     {
 249       err(c, "Missing command");
 250       return;
 251     }
 252   if (trace_commands)
 253     msg(L_DEBUG, "<< %s", cmd);
 254   if (!strcasecmp(cmd, "SUBMIT"))
 255     cmd_submit(c);
 256   else if (!strcasecmp(cmd, "STATUS"))
 257     cmd_status(c);
 258   else
 259     err(c, "Unknown command");
 260 }
 261
 262 int
 263 process_command(struct conn *c)
 264 {
 265   if (!read_request(c))
 266     return 0;
 267   execute_command(c);
 268   write_reply(c);
 269   return 1;
 270 }
 271
 272 /*** INITIAL HANDSHAKE ***/
 273
 274 static void
 275 execute_init(struct conn *c)
 276 {
 277   byte *user = obj_find_aval(c->request, 'U');
 278   if (!user)
 279     {
 280       err(c, "Missing user");
 281       return;
 282     }
 283   if (!c->cert_name ||
 284       !strcmp(user, c->cert_name) ||
 285       c->rule->allow_admin && !strcmp(c->cert_name, "admin"))
 286     {
 287       if (!user_exists_p(user))
 288         {
 289           err(c, "Unknown user");
 290           return;
 291         }
 292       msg(L_INFO, "Logged in %s", user);
 293     }
 294   else
 295     {
 296       err(c, "Permission denied");
 297       msg(L_ERROR, "Unauthorized attempt to log in as %s", user);
 298       return;
 299     }
 300   c->user = xstrdup(user);
 301 }
 302
 303 int
 304 process_init(struct conn *c)
 305 {
 306   if (!read_request(c))
 307     return 0;
 308   execute_init(c);
 309   write_reply(c);
 310   return !obj_find_attr(c->reply, '-');
 311 }