builtin/remote-ext.c

   1 #include "builtin.h"
   2 #include "transport.h"
   3 #include "run-command.h"
   4
   5 /*
   6  * URL syntax:
   7  *      'command [arg1 [arg2 [...]]]'   Invoke command with given arguments.
   8  *      Special characters:
   9  *      '% ': Literal space in argument.
  10  *      '%%': Literal percent sign.
  11  *      '%S': Name of service (git-upload-pack/git-upload-archive/
  12  *              git-receive-pack.
  13  *      '%s': Same as \s, but with possible git- prefix stripped.
  14  *      '%G': Only allowed as first 'character' of argument. Do not pass this
  15  *              Argument to command, instead send this as name of repository
  16  *              in in-line git://-style request (also activates sending this
  17  *              style of request).
  18  *      '%V': Only allowed as first 'character' of argument. Used in
  19  *              conjunction with '%G': Do not pass this argument to command,
  20  *              instead send this as vhost in git://-style request (note: does
  21  *              not activate sending git:// style request).
  22  */
  23
  24 static char *git_req;
  25 static char *git_req_vhost;
  26
  27 static char *strip_escapes(const char *str, const char *service,
  28         const char **next)
  29 {
  30         size_t rpos = 0;
  31         int escape = 0;
  32         char special = 0;
  33         const char *service_noprefix = service;
  34         struct strbuf ret = STRBUF_INIT;
  35
  36         skip_prefix(service_noprefix, "git-", &service_noprefix);
  37
  38         /* Pass the service to command. */
  39         setenv("GIT_EXT_SERVICE", service, 1);
  40         setenv("GIT_EXT_SERVICE_NOPREFIX", service_noprefix, 1);
  41
  42         /* Scan the length of argument. */
  43         while (str[rpos] && (escape || str[rpos] != ' ')) {
  44                 if (escape) {
  45                         switch (str[rpos]) {
  46                         case ' ':
  47                         case '%':
  48                         case 's':
  49                         case 'S':
  50                                 break;
  51                         case 'G':
  52                         case 'V':
  53                                 special = str[rpos];
  54                                 if (rpos == 1)
  55                                         break;
  56                                 /* Fall-through to error. */
  57                         default:
  58                                 die("Bad remote-ext placeholder '%%%c'.",
  59                                         str[rpos]);
  60                         }
  61                         escape = 0;
  62                 } else
  63                         escape = (str[rpos] == '%');
  64                 rpos++;
  65         }
  66         if (escape && !str[rpos])
  67                 die("remote-ext command has incomplete placeholder");
  68         *next = str + rpos;
  69         if (**next == ' ')
  70                 ++*next;        /* Skip over space */
  71
  72         /*
  73          * Do the actual placeholder substitution. The string will be short
  74          * enough not to overflow integers.
  75          */
  76         rpos = special ? 2 : 0;         /* Skip first 2 bytes in specials. */
  77         escape = 0;
  78         while (str[rpos] && (escape || str[rpos] != ' ')) {
  79                 if (escape) {
  80                         switch (str[rpos]) {
  81                         case ' ':
  82                         case '%':
  83                                 strbuf_addch(&ret, str[rpos]);
  84                                 break;
  85                         case 's':
  86                                 strbuf_addstr(&ret, service_noprefix);
  87                                 break;
  88                         case 'S':
  89                                 strbuf_addstr(&ret, service);
  90                                 break;
  91                         }
  92                         escape = 0;
  93                 } else
  94                         switch (str[rpos]) {
  95                         case '%':
  96                                 escape = 1;
  97                                 break;
  98                         default:
  99                                 strbuf_addch(&ret, str[rpos]);
 100                                 break;
 101                         }
 102                 rpos++;
 103         }
 104         switch (special) {
 105         case 'G':
 106                 git_req = strbuf_detach(&ret, NULL);
 107                 return NULL;
 108         case 'V':
 109                 git_req_vhost = strbuf_detach(&ret, NULL);
 110                 return NULL;
 111         default:
 112                 return strbuf_detach(&ret, NULL);
 113         }
 114 }
 115
 116 /* Should be enough... */
 117 #define MAXARGUMENTS 256
 118
 119 static const char **parse_argv(const char *arg, const char *service)
 120 {
 121         int arguments = 0;
 122         int i;
 123         const char **ret;
 124         char *temparray[MAXARGUMENTS + 1];
 125
 126         while (*arg) {
 127                 char *expanded;
 128                 if (arguments == MAXARGUMENTS)
 129                         die("remote-ext command has too many arguments");
 130                 expanded = strip_escapes(arg, service, &arg);
 131                 if (expanded)
 132                         temparray[arguments++] = expanded;
 133         }
 134
 135         ret = xmalloc((arguments + 1) * sizeof(char *));
 136         for (i = 0; i < arguments; i++)
 137                 ret[i] = temparray[i];
 138         ret[arguments] = NULL;
 139         return ret;
 140 }
 141
 142 static void send_git_request(int stdin_fd, const char *serv, const char *repo,
 143         const char *vhost)
 144 {
 145         size_t bufferspace;
 146         size_t wpos = 0;
 147         char *buffer;
 148
 149         /*
 150          * Request needs 12 bytes extra if there is vhost (xxxx \0host=\0) and
 151          * 6 bytes extra (xxxx \0) if there is no vhost.
 152          */
 153         if (vhost)
 154                 bufferspace = strlen(serv) + strlen(repo) + strlen(vhost) + 12;
 155         else
 156                 bufferspace = strlen(serv) + strlen(repo) + 6;
 157
 158         if (bufferspace > 0xFFFF)
 159                 die("Request too large to send");
 160         buffer = xmalloc(bufferspace);
 161
 162         /* Make the packet. */
 163         wpos = sprintf(buffer, "%04x%s %s%c", (unsigned)bufferspace,
 164                 serv, repo, 0);
 165
 166         /* Add vhost if any. */
 167         if (vhost)
 168                 sprintf(buffer + wpos, "host=%s%c", vhost, 0);
 169
 170         /* Send the request */
 171         if (write_in_full(stdin_fd, buffer, bufferspace) < 0)
 172                 die_errno("Failed to send request");
 173
 174         free(buffer);
 175 }
 176
 177 static int run_child(const char *arg, const char *service)
 178 {
 179         int r;
 180         struct child_process child = CHILD_PROCESS_INIT;
 181
 182         child.in = -1;
 183         child.out = -1;
 184         child.err = 0;
 185         child.argv = parse_argv(arg, service);
 186
 187         if (start_command(&child) < 0)
 188                 die("Can't run specified command");
 189
 190         if (git_req)
 191                 send_git_request(child.in, service, git_req, git_req_vhost);
 192
 193         r = bidirectional_transfer_loop(child.out, child.in);
 194         if (!r)
 195                 r = finish_command(&child);
 196         else
 197                 finish_command(&child);
 198         return r;
 199 }
 200
 201 #define MAXCOMMAND 4096
 202
 203 static int command_loop(const char *child)
 204 {
 205         char buffer[MAXCOMMAND];
 206
 207         while (1) {
 208                 size_t i;
 209                 if (!fgets(buffer, MAXCOMMAND - 1, stdin)) {
 210                         if (ferror(stdin))
 211                                 die("Comammand input error");
 212                         exit(0);
 213                 }
 214                 /* Strip end of line characters. */
 215                 i = strlen(buffer);
 216                 while (i > 0 && isspace(buffer[i - 1]))
 217                         buffer[--i] = 0;
 218
 219                 if (!strcmp(buffer, "capabilities")) {
 220                         printf("*connect\n\n");
 221                         fflush(stdout);
 222                 } else if (!strncmp(buffer, "connect ", 8)) {
 223                         printf("\n");
 224                         fflush(stdout);
 225                         return run_child(child, buffer + 8);
 226                 } else {
 227                         fprintf(stderr, "Bad command");
 228                         return 1;
 229                 }
 230         }
 231 }
 232
 233 int cmd_remote_ext(int argc, const char **argv, const char *prefix)
 234 {
 235         if (argc != 3)
 236                 die("Expected two arguments");
 237
 238         return command_loop(argv[2]);
 239 }