unrar_exec.c

   1 /*
   2  * List files and extract file from rars by using external executable unrar.
   3  *
   4  * Copyright (C) 2005 Jindrich Makovicka <makovick gmail com>
   5  * Copyright (C) 2007 Ulion <ulion2002 gmail com>
   6  *
   7  * This file is part of MPlayer.
   8  *
   9  * MPlayer is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * MPlayer is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23
  24 #include <sys/wait.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <locale.h>
  32 #include "unrar_exec.h"
  33
  34 #include "mp_msg.h"
  35
  36 #define UNRAR_LIST 1
  37 #define UNRAR_EXTRACT 2
  38
  39 char* unrar_executable = NULL;
  40
  41 static FILE* launch_pipe(pid_t *apid, const char *executable, int action,
  42                          const char *archive, const char *filename)
  43 {
  44   if (!executable || access(executable, R_OK | X_OK)) return NULL;
  45   if (access(archive, R_OK)) return NULL;
  46   {
  47     int mypipe[2];
  48     pid_t pid;
  49
  50     if (pipe(mypipe)) {
  51         mp_msg(MSGT_GLOBAL, MSGL_ERR, "UnRAR: Cannot create pipe.\n");
  52         return NULL;
  53     }
  54
  55     pid = fork();
  56     if (pid == 0) {
  57         /* This is the child process. Execute the unrar executable. */
  58         close(mypipe[0]);
  59         // Close MPlayer's stdin, stdout and stderr so the unrar binary
  60         // can not mess them up.
  61         // TODO: Close all other files except the pipe.
  62         close(0); close(1); close(2);
  63         // Assign new stdin, stdout and stderr and check they actually got the
  64         // right descriptors.
  65         if (open("/dev/null", O_RDONLY) != 0 || dup(mypipe[1]) != 1
  66                 || open("/dev/null", O_WRONLY) != 2)
  67             _exit(EXIT_FAILURE);
  68         if (action == UNRAR_LIST)
  69             execl(executable, executable, "v", archive, NULL);
  70         else if (action == UNRAR_EXTRACT)
  71             execl(executable, executable, "p", "-inul", "-p-",
  72                   archive,filename,NULL);
  73         mp_msg(MSGT_GLOBAL, MSGL_ERR, "UnRAR: Cannot execute %s\n", executable);
  74         _exit(EXIT_FAILURE);
  75     }
  76     if (pid < 0) {
  77         /* The fork failed.  Report failure.  */
  78         mp_msg(MSGT_GLOBAL, MSGL_ERR, "UnRAR: Fork failed\n");
  79         return NULL;
  80     }
  81     /* This is the parent process. Prepare the pipe stream. */
  82     close(mypipe[1]);
  83     *apid = pid;
  84     if (action == UNRAR_LIST)
  85         mp_msg(MSGT_GLOBAL, MSGL_V,
  86                "UnRAR: call unrar with command line: %s v %s\n",
  87                executable, archive);
  88     else if (action == UNRAR_EXTRACT)
  89         mp_msg(MSGT_GLOBAL, MSGL_V,
  90                "UnRAR: call unrar with command line: %s p -inul -p- %s %s\n",
  91                executable, archive, filename);
  92     return fdopen(mypipe[0], "r");
  93   }
  94 }
  95
  96 #define ALLOC_INCR 1 * 1024 * 1024
  97 int unrar_exec_get(unsigned char **output, unsigned long *size,
  98                    const char *filename, const char *rarfile)
  99 {
 100     int bufsize = ALLOC_INCR, bytesread;
 101     pid_t pid;
 102     int status = 0;
 103     FILE *rar_pipe;
 104
 105     rar_pipe=launch_pipe(&pid,unrar_executable,UNRAR_EXTRACT,rarfile,filename);
 106     if (!rar_pipe) return 0;
 107
 108     *size = 0;
 109
 110     *output = malloc(bufsize);
 111
 112     while (*output) {
 113         bytesread=fread(*output+*size, 1, bufsize-*size, rar_pipe);
 114         if (bytesread <= 0)
 115             break;
 116         *size += bytesread;
 117         if (*size == bufsize) {
 118             char *p;
 119             bufsize += ALLOC_INCR;
 120             p = realloc(*output, bufsize);
 121             if (!p)
 122                 free(*output);
 123             *output = p;
 124         }
 125     }
 126     fclose(rar_pipe);
 127     pid = waitpid(pid, &status, 0);
 128     if (!*output || !*size || (pid == -1 && errno != ECHILD) ||
 129             (pid > 0 && status)) {
 130         free(*output);
 131         *output = NULL;
 132         *size = 0;
 133         return 0;
 134     }
 135     if (bufsize > *size) {
 136         char *p = realloc(*output, *size);
 137         if (p)
 138             *output = p;
 139     }
 140     mp_msg(MSGT_GLOBAL, MSGL_V, "UnRAR: got file %s len %lu\n", filename,*size);
 141     return 1;
 142 }
 143
 144 #define PARSE_NAME 0
 145 #define PARSE_PROPS 1
 146
 147 int unrar_exec_list(const char *rarfile, ArchiveList_struct **list)
 148 {
 149     char buf[1024], fname[1024];
 150     char *p;
 151     pid_t pid;
 152     int status = 0, file_num = -1, ignore_next_line = 0, state = PARSE_NAME;
 153     FILE *rar_pipe;
 154     ArchiveList_struct *alist = NULL, *current = NULL, *new;
 155
 156     rar_pipe = launch_pipe(&pid, unrar_executable, UNRAR_LIST, rarfile, NULL);
 157     if (!rar_pipe) return -1;
 158     while (fgets(buf, sizeof(buf), rar_pipe)) {
 159         int packsize, unpsize, ratio, day, month, year, hour, min;
 160         int llen = strlen(buf);
 161         // If read nothing, we got a file_num -1.
 162         if (file_num == -1)
 163             file_num = 0;
 164         if (buf[llen-1] != '\n')
 165             // The line is too long, ignore it.
 166             ignore_next_line = 2;
 167         if (ignore_next_line) {
 168             --ignore_next_line;
 169             state = PARSE_NAME;
 170             continue;
 171         }
 172         // Trim the line.
 173         while (llen > 0 && strchr(" \t\n\r\v\f", buf[llen-1]))
 174             --llen;
 175         buf[llen] = '\0';
 176         p = buf;
 177         while (*p && strchr(" \t\n\r\v\f", *p))
 178             ++p;
 179         if (!*p) {
 180             state = PARSE_NAME;
 181             continue;
 182         }
 183
 184         if (state == PARSE_PROPS && sscanf(p, "%d %d %d%% %d-%d-%d %d:%d",
 185                                            &unpsize, &packsize, &ratio, &day,
 186                                            &month, &year, &hour, &min) == 8) {
 187             new = calloc(1, sizeof(ArchiveList_struct));
 188             if (!new) {
 189                 file_num = -1;
 190                 break;
 191             }
 192             if (!current)
 193                 alist = new;
 194             else
 195                 current->next = new;
 196             current = new;
 197             current->item.Name = strdup(fname);
 198             state = PARSE_NAME;
 199             if (!current->item.Name) {
 200                 file_num = -1;
 201                 break;
 202             }
 203             current->item.PackSize = packsize;
 204             current->item.UnpSize = unpsize;
 205             ++file_num;
 206             continue;
 207         }
 208         strcpy(fname, p);
 209         state = PARSE_PROPS;
 210     }
 211     fclose(rar_pipe);
 212     pid = waitpid(pid, &status, 0);
 213     if (file_num < 0 || (pid == -1 && errno != ECHILD) ||
 214             (pid > 0 && status)) {
 215         unrar_exec_freelist(alist);
 216         return -1;
 217     }
 218     if (!alist)
 219         return -1;
 220     *list = alist;
 221     mp_msg(MSGT_GLOBAL, MSGL_V, "UnRAR: list got %d files\n", file_num);
 222     return file_num;
 223 }
 224
 225 void unrar_exec_freelist(ArchiveList_struct *list)
 226 {
 227     ArchiveList_struct* tmp;
 228
 229     while (list) {
 230         tmp = list->next;
 231         free(list->item.Name);
 232         free(list);
 233         list = tmp;
 234     }
 235 }