libmenu/menu_filesel.c

   1
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <dirent.h>
   5 #include <errno.h>
   6 #include <string.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <fcntl.h>
  10 #include <ctype.h>
  11 #include <unistd.h>
  12 #include <limits.h>
  13
  14
  15 #include "config.h"
  16 #include "mp_msg.h"
  17 #include "help_mp.h"
  18
  19 #include "m_struct.h"
  20 #include "m_option.h"
  21
  22 #include "libmpcodecs/img_format.h"
  23 #include "libmpcodecs/mp_image.h"
  24
  25 #include "menu.h"
  26 #include "menu_list.h"
  27 #include "input/input.h"
  28 #include "osdep/keycodes.h"
  29
  30 #define MENU_KEEP_PATH "/tmp/mp_current_path"
  31
  32 int menu_keepdir = 0;
  33 char *menu_chroot = NULL;
  34
  35 struct list_entry_s {
  36   struct list_entry p;
  37   int d;
  38 };
  39
  40 struct menu_priv_s {
  41   menu_list_priv_t p;
  42   char* dir; // current dir
  43   /// Cfg fields
  44   char* path;
  45   char* title;
  46   char* file_action;
  47   char* dir_action;
  48   int auto_close;
  49   char** actions;
  50   char* filter;
  51 };
  52
  53 static struct menu_priv_s cfg_dflt = {
  54   MENU_LIST_PRIV_DFLT,
  55   NULL,
  56
  57   NULL,
  58   "Select a file: %p",
  59   "loadfile '%p'",
  60   NULL,
  61   0,
  62   NULL,
  63   NULL
  64 };
  65
  66 #define ST_OFF(m) M_ST_OFF(struct menu_priv_s,m)
  67
  68 static m_option_t cfg_fields[] = {
  69   MENU_LIST_PRIV_FIELDS,
  70   { "path", ST_OFF(path),  CONF_TYPE_STRING, 0, 0, 0, NULL },
  71   { "title", ST_OFF(title),  CONF_TYPE_STRING, 0, 0, 0, NULL },
  72   { "file-action", ST_OFF(file_action),  CONF_TYPE_STRING, 0, 0, 0, NULL },
  73   { "dir-action", ST_OFF(dir_action),  CONF_TYPE_STRING, 0, 0, 0, NULL },
  74   { "auto-close", ST_OFF(auto_close), CONF_TYPE_FLAG, 0, 0, 1, NULL },
  75   { "actions", ST_OFF(actions), CONF_TYPE_STRING_LIST, 0, 0, 0, NULL},
  76   { "filter", ST_OFF(filter), CONF_TYPE_STRING, 0, 0, 0, NULL},
  77   { NULL, NULL, NULL, 0,0,0,NULL }
  78 };
  79
  80 #define mpriv (menu->priv)
  81
  82 static void free_entry(list_entry_t* entry) {
  83   free(entry->p.txt);
  84   free(entry);
  85 }
  86
  87 static char* replace_path(char* title , char* dir) {
  88   char *p = strstr(title,"%p");
  89   if(p) {
  90     int tl = strlen(title);
  91     int dl = strlen(dir);
  92     int t1l = p-title;
  93     int l = tl - 2 + dl;
  94     char *r, *n, *d = dir;
  95     char term = *(p-1);
  96
  97     do {
  98       if (*d == '\\' || *d == term)
  99         l++;
 100     } while (*d++);
 101     r = malloc(l + 1);
 102     n = r + t1l;
 103     memcpy(r,title,t1l);
 104     do {
 105       if (*dir == '\\' || *dir == term)
 106         *n++ = '\\';
 107     } while ((*n++ = *dir++));
 108     if(tl - t1l - 2 > 0)
 109       strcpy(n-1,p+2);
 110     return r;
 111   } else
 112     return title;
 113 }
 114
 115 typedef int (*kill_warn)(const void*, const void*);
 116
 117 static int mylstat(char *dir, char *file,struct stat* st) {
 118   int l = strlen(dir) + strlen(file);
 119   char s[l+2];
 120   sprintf(s,"%s/%s",dir,file);
 121   return stat(s,st);
 122 }
 123
 124 static int compare(char **a, char **b){
 125   if((*a)[strlen(*a) - 1] == '/') {
 126     if((*b)[strlen(*b) - 1] == '/')
 127       return strcmp(*b, *a) ;
 128     else
 129       return 1;
 130   } else {
 131     if((*b)[strlen(*b) - 1] == '/')
 132       return -1;
 133     else
 134       return strcmp(*b, *a);
 135   }
 136 }
 137
 138 static char **get_extensions(menu_t *menu){
 139   char **extensions, ext[32];
 140   FILE *fp;
 141   int n = 1;
 142
 143   if (!mpriv->filter)
 144     return NULL;
 145
 146   fp = fopen(mpriv->filter, "r");
 147   if(!fp)
 148     return NULL;
 149
 150   extensions = (char **) malloc(sizeof(*extensions));
 151   *extensions = NULL;
 152
 153   while(fgets(ext,sizeof(ext),fp)) {
 154     char **l, *e;
 155     int s = strlen (ext);
 156
 157     if(ext[s-1] == '\n') {
 158       ext[s-1] = '\0';
 159       s--;
 160     }
 161     e = (char *) malloc(s+1);
 162     extensions = (char **) realloc(extensions, ++n * sizeof(*extensions));
 163     extensions = (char **) realloc(extensions, ++n * sizeof(*extensions));
 164     strcpy (e, ext);
 165     for (l=extensions; *l; l++);
 166     *l++ = e;
 167     *l = NULL;
 168   }
 169
 170   fclose (fp);
 171   return extensions;
 172 }
 173
 174 static void free_extensions(char **extensions){
 175   if (extensions) {
 176     char **l = extensions;
 177     while (*l)
 178       free (*l++);
 179     free (extensions);
 180   }
 181 }
 182
 183 static int open_dir(menu_t* menu,char* args) {
 184   char **namelist, **tp;
 185   struct dirent *dp;
 186   struct stat st;
 187   int n;
 188   int path_fp;
 189   char* p = NULL;
 190   list_entry_t* e;
 191   DIR* dirp;
 192   extern int file_filter;
 193   char **extensions, **elem, *ext;
 194
 195   menu_list_init(menu);
 196
 197   if(mpriv->dir)
 198     free(mpriv->dir);
 199   mpriv->dir = strdup(args);
 200   if(mpriv->p.title && mpriv->p.title != mpriv->title && mpriv->p.title != cfg_dflt.p.title)
 201     free(mpriv->p.title);
 202   p = strstr(mpriv->title,"%p");
 203
 204   mpriv->p.title = replace_path(mpriv->title,mpriv->dir);
 205
 206   if ((dirp = opendir (mpriv->dir)) == NULL){
 207     mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_OpendirError, strerror(errno));
 208     return 0;
 209   }
 210
 211   if (menu_keepdir) {
 212     path_fp = open (MENU_KEEP_PATH, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 213     if (path_fp >= 0) {
 214       write (path_fp, mpriv->dir, strlen (mpriv->dir));
 215       close (path_fp);
 216     }
 217   }
 218
 219   namelist = (char **) malloc(sizeof(char *));
 220   extensions = get_extensions(menu);
 221
 222   n=0;
 223   while ((dp = readdir(dirp)) != NULL) {
 224     if(dp->d_name[0] == '.' && strcmp(dp->d_name,"..") != 0)
 225       continue;
 226     if (menu_chroot && !strcmp (dp->d_name,"..")) {
 227       int len = strlen (menu_chroot);
 228       if ((strlen (mpriv->dir) == len || strlen (mpriv->dir) == len + 1)
 229           && !strncmp (mpriv->dir, menu_chroot, len))
 230         continue;
 231     }
 232     mylstat(args,dp->d_name,&st);
 233     if (file_filter && extensions && !S_ISDIR(st.st_mode)) {
 234       if((ext = strrchr(dp->d_name,'.')) == NULL)
 235         continue;
 236       ext++;
 237       elem = extensions;
 238       do {
 239         if (!strcasecmp(ext, *elem))
 240           break;
 241       } while (*++elem);
 242       if (*elem == NULL)
 243         continue;
 244     }
 245     if(n%20 == 0){ // Get some more mem
 246       if((tp = (char **) realloc(namelist, (n+20) * sizeof (char *)))
 247          == NULL) {
 248         mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_ReallocError, strerror(errno));
 249         n--;
 250         goto bailout;
 251       }
 252       namelist=tp;
 253     }
 254
 255     namelist[n] = (char *) malloc(strlen(dp->d_name) + 2);
 256     if(namelist[n] == NULL){
 257       mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_MallocError, strerror(errno));
 258       n--;
 259       goto bailout;
 260     }
 261
 262     strcpy(namelist[n], dp->d_name);
 263     if(S_ISDIR(st.st_mode))
 264       strcat(namelist[n], "/");
 265     n++;
 266   }
 267
 268 bailout:
 269   free_extensions (extensions);
 270   closedir(dirp);
 271
 272   qsort(namelist, n, sizeof(char *), (kill_warn)compare);
 273
 274   if (n < 0) {
 275     mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_ReaddirError,strerror(errno));
 276     return 0;
 277   }
 278   while(n--) {
 279     if((e = calloc(1,sizeof(list_entry_t))) != NULL){
 280     e->p.next = NULL;
 281     e->p.txt = strdup(namelist[n]);
 282     if(strchr(namelist[n], '/') != NULL)
 283       e->d = 1;
 284     menu_list_add_entry(menu,e);
 285     }else{
 286       mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_MallocError, strerror(errno));
 287     }
 288     free(namelist[n]);
 289   }
 290   free(namelist);
 291
 292   return 1;
 293 }
 294
 295
 296 static char *action;
 297
 298 static void read_cmd(menu_t* menu,int cmd) {
 299   mp_cmd_t* c = NULL;
 300   switch(cmd) {
 301   case MENU_CMD_LEFT:
 302     mpriv->p.current = mpriv->p.menu; // Hack : we consider that the first entry is ../
 303   case MENU_CMD_RIGHT:
 304   case MENU_CMD_OK: {
 305     // Directory
 306     if(mpriv->p.current->d) {
 307       if(mpriv->dir_action) {
 308         int fname_len = strlen(mpriv->dir) + strlen(mpriv->p.current->p.txt) + 1;
 309         char filename[fname_len];
 310         char* str;
 311         sprintf(filename,"%s%s",mpriv->dir,mpriv->p.current->p.txt);
 312         str = replace_path(mpriv->dir_action,filename);
 313         c = mp_input_parse_cmd(str);
 314         if(str != mpriv->dir_action)
 315           free(str);
 316       } else { // Default action : open this dirctory ourself
 317         int l = strlen(mpriv->dir);
 318         char *slash =  NULL, *p = NULL;
 319         if(strcmp(mpriv->p.current->p.txt,"../") == 0) {
 320           if(l <= 1) break;
 321           mpriv->dir[l-1] = '\0';
 322           slash = strrchr(mpriv->dir,'/');
 323 #if defined(__MINGW32__) || defined(__CYGWIN__)
 324           if (!slash)
 325             slash = strrchr(mpriv->dir,'\\');
 326 #endif
 327           if(!slash) break;
 328           slash[1] = '\0';
 329           p = strdup(mpriv->dir);
 330         } else {
 331           p = malloc(l + strlen(mpriv->p.current->p.txt) + 1);
 332           sprintf(p,"%s%s",mpriv->dir,mpriv->p.current->p.txt);
 333         }
 334         menu_list_uninit(menu,free_entry);
 335         if(!open_dir(menu,p)) {
 336           mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_LIBMENU_CantOpenDirectory,p);
 337           menu->cl = 1;
 338         }
 339         free(p);
 340       }
 341     } else { // Files
 342       int fname_len = strlen(mpriv->dir) + strlen(mpriv->p.current->p.txt) + 1;
 343       char filename[fname_len];
 344       char *str;
 345       sprintf(filename,"%s%s",mpriv->dir,mpriv->p.current->p.txt);
 346       str = replace_path(mpriv->file_action,filename);
 347       c = mp_input_parse_cmd(str);
 348       if(str != mpriv->file_action)
 349         free(str);
 350     }
 351     if(c) {
 352       mp_input_queue_cmd(c);
 353       if(mpriv->auto_close)
 354         menu->cl = 1;
 355     }
 356   } break;
 357   case MENU_CMD_ACTION: {
 358     int fname_len = strlen(mpriv->dir) + strlen(mpriv->p.current->p.txt) + 1;
 359     char filename[fname_len];
 360     char *str;
 361     sprintf(filename,"%s%s",mpriv->dir,mpriv->p.current->p.txt);
 362     str = replace_path(action, filename);
 363     mp_input_queue_cmd(mp_input_parse_cmd(str));
 364     if(str != action)
 365       free(str);
 366   } break;
 367   default:
 368     menu_list_read_cmd(menu,cmd);
 369   }
 370 }
 371
 372 static void read_key(menu_t* menu,int c){
 373   if(c == KEY_BS)
 374     read_cmd(menu,MENU_CMD_LEFT);
 375   else {
 376     char **str;
 377     for (str=mpriv->actions; str && *str; str++)
 378       if (c == (*str)[0]) {
 379         action = &(*str)[2];
 380         read_cmd(menu,MENU_CMD_ACTION);
 381         break;
 382       }
 383     if (!str || !*str)
 384       menu_list_read_key(menu,c,1);
 385   }
 386 }
 387
 388 static void clos(menu_t* menu) {
 389   menu_list_uninit(menu,free_entry);
 390   free(mpriv->dir);
 391 }
 392
 393 static int open_fs(menu_t* menu, char* args) {
 394   char *path = mpriv->path, *freepath = NULL;
 395   int r = 0;
 396   char wd[PATH_MAX+1];
 397   args = NULL; // Warning kill
 398
 399   menu->draw = menu_list_draw;
 400   menu->read_cmd = read_cmd;
 401   menu->read_key = read_key;
 402   menu->close = clos;
 403
 404   if (menu_keepdir) {
 405     if (!path || path[0] == '\0') {
 406       struct stat st;
 407       int path_fp;
 408
 409       path_fp = open (MENU_KEEP_PATH, O_RDONLY);
 410       if (path_fp >= 0) {
 411         if (!fstat (path_fp, &st) && (st.st_size > 0)) {
 412           path = malloc(st.st_size+1);
 413           if ((read(path_fp, path, st.st_size) == st.st_size) && path[0] != '\0'){
 414             freepath = path;
 415             path[st.st_size] = '\0';
 416           }
 417           else {
 418             free(path);
 419             path = NULL;
 420           }
 421         }
 422         close (path_fp);
 423       }
 424     }
 425   }
 426
 427   getcwd(wd,PATH_MAX);
 428   if(!path || path[0] == '\0') {
 429     int l = strlen(wd) + 2;
 430     char b[l];
 431     sprintf(b,"%s/",wd);
 432     r = open_dir(menu,b);
 433   } else if(path[0] != '/') {
 434     int al = strlen(path);
 435     int l = strlen(wd) + al + 3;
 436     char b[l];
 437     if(b[al-1] != '/')
 438       sprintf(b,"%s/%s/",wd,path);
 439     else
 440       sprintf(b,"%s/%s",wd,path);
 441     r = open_dir(menu,b);
 442   } else
 443     r = open_dir(menu,path);
 444
 445   if (freepath)
 446     free(freepath);
 447
 448   return r;
 449 }
 450
 451 const menu_info_t menu_info_filesel = {
 452   "File seletor menu",
 453   "filesel",
 454   "Albeu",
 455   "",
 456   {
 457     "fs_cfg",
 458     sizeof(struct menu_priv_s),
 459     &cfg_dflt,
 460     cfg_fields
 461   },
 462   open_fs
 463 };