slirp/tftp.c

   1 /*
   2  * tftp.c - a simple, read-only tftp server for qemu
   3  *
   4  * Copyright (c) 2004 Magnus Damm <[email protected]>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include <slirp.h>
  26 #include "qemu-common.h"
  27
  28 static inline int tftp_session_in_use(struct tftp_session *spt)
  29 {
  30     return (spt->slirp != NULL);
  31 }
  32
  33 static inline void tftp_session_update(struct tftp_session *spt)
  34 {
  35     spt->timestamp = curtime;
  36 }
  37
  38 static void tftp_session_terminate(struct tftp_session *spt)
  39 {
  40     if (spt->fd >= 0) {
  41         close(spt->fd);
  42         spt->fd = -1;
  43     }
  44     g_free(spt->filename);
  45     spt->slirp = NULL;
  46 }
  47
  48 static int tftp_session_allocate(Slirp *slirp, struct tftp_t *tp)
  49 {
  50   struct tftp_session *spt;
  51   int k;
  52
  53   for (k = 0; k < TFTP_SESSIONS_MAX; k++) {
  54     spt = &slirp->tftp_sessions[k];
  55
  56     if (!tftp_session_in_use(spt))
  57         goto found;
  58
  59     /* sessions time out after 5 inactive seconds */
  60     if ((int)(curtime - spt->timestamp) > 5000) {
  61         tftp_session_terminate(spt);
  62         goto found;
  63     }
  64   }
  65
  66   return -1;
  67
  68  found:
  69   memset(spt, 0, sizeof(*spt));
  70   memcpy(&spt->client_ip, &tp->ip.ip_src, sizeof(spt->client_ip));
  71   spt->fd = -1;
  72   spt->client_port = tp->udp.uh_sport;
  73   spt->slirp = slirp;
  74
  75   tftp_session_update(spt);
  76
  77   return k;
  78 }
  79
  80 static int tftp_session_find(Slirp *slirp, struct tftp_t *tp)
  81 {
  82   struct tftp_session *spt;
  83   int k;
  84
  85   for (k = 0; k < TFTP_SESSIONS_MAX; k++) {
  86     spt = &slirp->tftp_sessions[k];
  87
  88     if (tftp_session_in_use(spt)) {
  89       if (!memcmp(&spt->client_ip, &tp->ip.ip_src, sizeof(spt->client_ip))) {
  90         if (spt->client_port == tp->udp.uh_sport) {
  91           return k;
  92         }
  93       }
  94     }
  95   }
  96
  97   return -1;
  98 }
  99
 100 static int tftp_read_data(struct tftp_session *spt, uint32_t block_nr,
 101                           uint8_t *buf, int len)
 102 {
 103     int bytes_read = 0;
 104
 105     if (spt->fd < 0) {
 106         spt->fd = open(spt->filename, O_RDONLY | O_BINARY);
 107     }
 108
 109     if (spt->fd < 0) {
 110         return -1;
 111     }
 112
 113     if (len) {
 114         lseek(spt->fd, block_nr * 512, SEEK_SET);
 115
 116         bytes_read = read(spt->fd, buf, len);
 117     }
 118
 119     return bytes_read;
 120 }
 121
 122 static int tftp_send_oack(struct tftp_session *spt,
 123                           const char *keys[], uint32_t values[], int nb,
 124                           struct tftp_t *recv_tp)
 125 {
 126     struct sockaddr_in saddr, daddr;
 127     struct mbuf *m;
 128     struct tftp_t *tp;
 129     int i, n = 0;
 130
 131     m = m_get(spt->slirp);
 132
 133     if (!m)
 134         return -1;
 135
 136     memset(m->m_data, 0, m->m_size);
 137
 138     m->m_data += IF_MAXLINKHDR;
 139     tp = (void *)m->m_data;
 140     m->m_data += sizeof(struct udpiphdr);
 141
 142     tp->tp_op = htons(TFTP_OACK);
 143     for (i = 0; i < nb; i++) {
 144         n += snprintf(tp->x.tp_buf + n, sizeof(tp->x.tp_buf) - n, "%s",
 145                       keys[i]) + 1;
 146         n += snprintf(tp->x.tp_buf + n, sizeof(tp->x.tp_buf) - n, "%u",
 147                       values[i]) + 1;
 148     }
 149
 150     saddr.sin_addr = recv_tp->ip.ip_dst;
 151     saddr.sin_port = recv_tp->udp.uh_dport;
 152
 153     daddr.sin_addr = spt->client_ip;
 154     daddr.sin_port = spt->client_port;
 155
 156     m->m_len = sizeof(struct tftp_t) - 514 + n -
 157         sizeof(struct ip) - sizeof(struct udphdr);
 158     udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
 159
 160     return 0;
 161 }
 162
 163 static void tftp_send_error(struct tftp_session *spt,
 164                             uint16_t errorcode, const char *msg,
 165                             struct tftp_t *recv_tp)
 166 {
 167   struct sockaddr_in saddr, daddr;
 168   struct mbuf *m;
 169   struct tftp_t *tp;
 170
 171   m = m_get(spt->slirp);
 172
 173   if (!m) {
 174     goto out;
 175   }
 176
 177   memset(m->m_data, 0, m->m_size);
 178
 179   m->m_data += IF_MAXLINKHDR;
 180   tp = (void *)m->m_data;
 181   m->m_data += sizeof(struct udpiphdr);
 182
 183   tp->tp_op = htons(TFTP_ERROR);
 184   tp->x.tp_error.tp_error_code = htons(errorcode);
 185   pstrcpy((char *)tp->x.tp_error.tp_msg, sizeof(tp->x.tp_error.tp_msg), msg);
 186
 187   saddr.sin_addr = recv_tp->ip.ip_dst;
 188   saddr.sin_port = recv_tp->udp.uh_dport;
 189
 190   daddr.sin_addr = spt->client_ip;
 191   daddr.sin_port = spt->client_port;
 192
 193   m->m_len = sizeof(struct tftp_t) - 514 + 3 + strlen(msg) -
 194         sizeof(struct ip) - sizeof(struct udphdr);
 195
 196   udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
 197
 198 out:
 199   tftp_session_terminate(spt);
 200 }
 201
 202 static void tftp_send_next_block(struct tftp_session *spt,
 203                                  struct tftp_t *recv_tp)
 204 {
 205   struct sockaddr_in saddr, daddr;
 206   struct mbuf *m;
 207   struct tftp_t *tp;
 208   int nobytes;
 209
 210   m = m_get(spt->slirp);
 211
 212   if (!m) {
 213     return;
 214   }
 215
 216   memset(m->m_data, 0, m->m_size);
 217
 218   m->m_data += IF_MAXLINKHDR;
 219   tp = (void *)m->m_data;
 220   m->m_data += sizeof(struct udpiphdr);
 221
 222   tp->tp_op = htons(TFTP_DATA);
 223   tp->x.tp_data.tp_block_nr = htons((spt->block_nr + 1) & 0xffff);
 224
 225   saddr.sin_addr = recv_tp->ip.ip_dst;
 226   saddr.sin_port = recv_tp->udp.uh_dport;
 227
 228   daddr.sin_addr = spt->client_ip;
 229   daddr.sin_port = spt->client_port;
 230
 231   nobytes = tftp_read_data(spt, spt->block_nr, tp->x.tp_data.tp_buf, 512);
 232
 233   if (nobytes < 0) {
 234     m_free(m);
 235
 236     /* send "file not found" error back */
 237
 238     tftp_send_error(spt, 1, "File not found", tp);
 239
 240     return;
 241   }
 242
 243   m->m_len = sizeof(struct tftp_t) - (512 - nobytes) -
 244         sizeof(struct ip) - sizeof(struct udphdr);
 245
 246   udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
 247
 248   if (nobytes == 512) {
 249     tftp_session_update(spt);
 250   }
 251   else {
 252     tftp_session_terminate(spt);
 253   }
 254
 255   spt->block_nr++;
 256 }
 257
 258 static void tftp_handle_rrq(Slirp *slirp, struct tftp_t *tp, int pktlen)
 259 {
 260   struct tftp_session *spt;
 261   int s, k;
 262   size_t prefix_len;
 263   char *req_fname;
 264   const char *option_name[2];
 265   uint32_t option_value[2];
 266   int nb_options = 0;
 267
 268   /* check if a session already exists and if so terminate it */
 269   s = tftp_session_find(slirp, tp);
 270   if (s >= 0) {
 271     tftp_session_terminate(&slirp->tftp_sessions[s]);
 272   }
 273
 274   s = tftp_session_allocate(slirp, tp);
 275
 276   if (s < 0) {
 277     return;
 278   }
 279
 280   spt = &slirp->tftp_sessions[s];
 281
 282   /* unspecified prefix means service disabled */
 283   if (!slirp->tftp_prefix) {
 284       tftp_send_error(spt, 2, "Access violation", tp);
 285       return;
 286   }
 287
 288   /* skip header fields */
 289   k = 0;
 290   pktlen -= offsetof(struct tftp_t, x.tp_buf);
 291
 292   /* prepend tftp_prefix */
 293   prefix_len = strlen(slirp->tftp_prefix);
 294   spt->filename = g_malloc(prefix_len + TFTP_FILENAME_MAX + 2);
 295   memcpy(spt->filename, slirp->tftp_prefix, prefix_len);
 296   spt->filename[prefix_len] = '/';
 297
 298   /* get name */
 299   req_fname = spt->filename + prefix_len + 1;
 300
 301   while (1) {
 302     if (k >= TFTP_FILENAME_MAX || k >= pktlen) {
 303       tftp_send_error(spt, 2, "Access violation", tp);
 304       return;
 305     }
 306     req_fname[k] = tp->x.tp_buf[k];
 307     if (req_fname[k++] == '\0') {
 308       break;
 309     }
 310   }
 311
 312   /* check mode */
 313   if ((pktlen - k) < 6) {
 314     tftp_send_error(spt, 2, "Access violation", tp);
 315     return;
 316   }
 317
 318   if (strcasecmp(&tp->x.tp_buf[k], "octet") != 0) {
 319       tftp_send_error(spt, 4, "Unsupported transfer mode", tp);
 320       return;
 321   }
 322
 323   k += 6; /* skipping octet */
 324
 325   /* do sanity checks on the filename */
 326   if (!strncmp(req_fname, "../", 3) ||
 327       req_fname[strlen(req_fname) - 1] == '/' ||
 328       strstr(req_fname, "/../")) {
 329       tftp_send_error(spt, 2, "Access violation", tp);
 330       return;
 331   }
 332
 333   /* check if the file exists */
 334   if (tftp_read_data(spt, 0, NULL, 0) < 0) {
 335       tftp_send_error(spt, 1, "File not found", tp);
 336       return;
 337   }
 338
 339   if (tp->x.tp_buf[pktlen - 1] != 0) {
 340       tftp_send_error(spt, 2, "Access violation", tp);
 341       return;
 342   }
 343
 344   while (k < pktlen && nb_options < ARRAY_SIZE(option_name)) {
 345       const char *key, *value;
 346
 347       key = &tp->x.tp_buf[k];
 348       k += strlen(key) + 1;
 349
 350       if (k >= pktlen) {
 351           tftp_send_error(spt, 2, "Access violation", tp);
 352           return;
 353       }
 354
 355       value = &tp->x.tp_buf[k];
 356       k += strlen(value) + 1;
 357
 358       if (strcasecmp(key, "tsize") == 0) {
 359           int tsize = atoi(value);
 360           struct stat stat_p;
 361
 362           if (tsize == 0) {
 363               if (stat(spt->filename, &stat_p) == 0)
 364                   tsize = stat_p.st_size;
 365               else {
 366                   tftp_send_error(spt, 1, "File not found", tp);
 367                   return;
 368               }
 369           }
 370
 371           option_name[nb_options] = "tsize";
 372           option_value[nb_options] = tsize;
 373           nb_options++;
 374       } else if (strcasecmp(key, "blksize") == 0) {
 375           int blksize = atoi(value);
 376
 377           /* If blksize option is bigger than what we will
 378            * emit, accept the option with our packet size.
 379            * Otherwise, simply do as we didn't see the option.
 380            */
 381           if (blksize >= 512) {
 382               option_name[nb_options] = "blksize";
 383               option_value[nb_options] = 512;
 384               nb_options++;
 385           }
 386       }
 387   }
 388
 389   if (nb_options > 0) {
 390       assert(nb_options <= ARRAY_SIZE(option_name));
 391       tftp_send_oack(spt, option_name, option_value, nb_options, tp);
 392       return;
 393   }
 394
 395   spt->block_nr = 0;
 396   tftp_send_next_block(spt, tp);
 397 }
 398
 399 static void tftp_handle_ack(Slirp *slirp, struct tftp_t *tp, int pktlen)
 400 {
 401   int s;
 402
 403   s = tftp_session_find(slirp, tp);
 404
 405   if (s < 0) {
 406     return;
 407   }
 408
 409   tftp_send_next_block(&slirp->tftp_sessions[s], tp);
 410 }
 411
 412 static void tftp_handle_error(Slirp *slirp, struct tftp_t *tp, int pktlen)
 413 {
 414   int s;
 415
 416   s = tftp_session_find(slirp, tp);
 417
 418   if (s < 0) {
 419     return;
 420   }
 421
 422   tftp_session_terminate(&slirp->tftp_sessions[s]);
 423 }
 424
 425 void tftp_input(struct mbuf *m)
 426 {
 427   struct tftp_t *tp = (struct tftp_t *)m->m_data;
 428
 429   switch(ntohs(tp->tp_op)) {
 430   case TFTP_RRQ:
 431     tftp_handle_rrq(m->slirp, tp, m->m_len);
 432     break;
 433
 434   case TFTP_ACK:
 435     tftp_handle_ack(m->slirp, tp, m->m_len);
 436     break;
 437
 438   case TFTP_ERROR:
 439     tftp_handle_error(m->slirp, tp, m->m_len);
 440     break;
 441   }
 442 }