builtin/remote-ext.c

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