src/ecoli_node_file.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
   3  */
   4
   5 #include <sys/types.h>
   6 #include <sys/stat.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <unistd.h>
  12 #include <dirent.h>
  13
  14 #include <ecoli_log.h>
  15 #include <ecoli_malloc.h>
  16 #include <ecoli_test.h>
  17 #include <ecoli_strvec.h>
  18 #include <ecoli_string.h>
  19 #include <ecoli_node.h>
  20 #include <ecoli_parse.h>
  21 #include <ecoli_complete.h>
  22 #include <ecoli_node_file.h>
  23
  24 EC_LOG_TYPE_REGISTER(node_file);
  25
  26 struct ec_node_file {
  27         struct ec_node gen;
  28
  29         /* below functions pointers are only useful for test */
  30         int (*lstat)(const char *pathname, struct stat *buf);
  31         DIR *(*opendir)(const char *name);
  32         struct dirent *(*readdir)(DIR *dirp);
  33         int (*closedir)(DIR *dirp);
  34         int (*dirfd)(DIR *dirp);
  35         int (*fstatat)(int dirfd, const char *pathname, struct stat *buf,
  36                 int flags);
  37 };
  38
  39 static int
  40 ec_node_file_parse(const struct ec_node *gen_node,
  41                 struct ec_parse *state,
  42                 const struct ec_strvec *strvec)
  43 {
  44         (void)gen_node;
  45         (void)state;
  46
  47         if (ec_strvec_len(strvec) == 0)
  48                 return EC_PARSE_NOMATCH;
  49
  50         return 1;
  51 }
  52
  53 /*
  54  * Almost the same than dirname (3) and basename (3) except that:
  55  * - it always returns a substring of the given path, which can
  56  *   be empty.
  57  * - the behavior is different when the path finishes with a '/'
  58  * - the path argument is not modified
  59  * - the outputs are allocated and must be freed with ec_free().
  60  *
  61  *   path       dirname   basename       split_path
  62  *   /usr/lib   /usr      lib          /usr/     lib
  63  *   /usr/      /         usr          /usr/
  64  *   usr        .         usr                    usr
  65  *   /          /         /            /
  66  *   .          .         .                      .
  67  *   ..         .         ..                     ..
  68  */
  69 static int split_path(const char *path, char **dname_p, char **bname_p)
  70 {
  71         char *last_slash;
  72         size_t dirlen;
  73         char *dname, *bname;
  74
  75         *dname_p = NULL;
  76         *bname_p = NULL;
  77
  78         last_slash = strrchr(path, '/');
  79         if (last_slash == NULL)
  80                 dirlen = 0;
  81         else
  82                 dirlen = last_slash - path + 1;
  83
  84         dname = ec_strdup(path);
  85         if (dname == NULL)
  86                 return -1;
  87         dname[dirlen] = '\0';
  88
  89         bname = ec_strdup(path + dirlen);
  90         if (bname == NULL) {
  91                 ec_free(dname);
  92                 return -1;
  93         }
  94
  95         *dname_p = dname;
  96         *bname_p = bname;
  97
  98         return 0;
  99 }
 100
 101 static int
 102 ec_node_file_complete(const struct ec_node *gen_node,
 103                 struct ec_comp *comp,
 104                 const struct ec_strvec *strvec)
 105 {
 106         struct ec_node_file *node = (struct ec_node_file *)gen_node;
 107         char *dname = NULL, *bname = NULL, *effective_dir;
 108         struct ec_comp_item *item = NULL;
 109         enum ec_comp_type type;
 110         struct stat st, st2;
 111         const char *input;
 112         size_t bname_len;
 113         struct dirent *de = NULL;
 114         DIR *dir = NULL;
 115         char *comp_str = NULL;
 116         char *disp_str = NULL;
 117         int is_dir = 0;
 118
 119         /*
 120          * Example with this file tree:
 121          * /
 122          * ├── dir1
 123          * │   ├── file1
 124          * │   ├── file2
 125          * │   └── subdir
 126          * │       └── file3
 127          * ├── dir2
 128          * │   └── file4
 129          * └── file5
 130          *
 131          * Input     Output completions
 132          *   /       [dir1/, dir2/, file5]
 133          *   /d      [dir1/, dir2/]
 134          *   /f      [file5]
 135          *   /dir1/  [file1, file2, subdir/]
 136          *
 137          *
 138          *
 139          */
 140
 141         if (ec_strvec_len(strvec) != 1)
 142                 return 0;
 143
 144         input = ec_strvec_val(strvec, 0);
 145         if (split_path(input, &dname, &bname) < 0)
 146                 return -1;
 147
 148         if (strcmp(dname, "") == 0)
 149                 effective_dir = ".";
 150         else
 151                 effective_dir = dname;
 152
 153         if (node->lstat(effective_dir, &st) < 0)
 154                 goto fail;
 155         if (!S_ISDIR(st.st_mode))
 156                 goto out;
 157
 158         dir = node->opendir(effective_dir);
 159         if (dir == NULL)
 160                 goto fail;
 161
 162         bname_len = strlen(bname);
 163         while (1) {
 164                 int save_errno = errno;
 165
 166                 errno = 0;
 167                 de = node->readdir(dir);
 168                 if (de == NULL) {
 169                         if (errno == 0) {
 170                                 errno = save_errno;
 171                                 goto out;
 172                         } else {
 173                                 goto fail;
 174                         }
 175                 }
 176
 177                 if (!ec_str_startswith(de->d_name, bname))
 178                         continue;
 179                 if (bname[0] != '.' && de->d_name[0] == '.')
 180                         continue;
 181
 182                 /* add '/' if it's a dir */
 183                 if (de->d_type == DT_DIR) {
 184                         is_dir = 1;
 185                 } else if (de->d_type == DT_UNKNOWN) {
 186                         int dir_fd = node->dirfd(dir);
 187
 188                         if (dir_fd < 0)
 189                                 goto fail;
 190                         if (node->fstatat(dir_fd, de->d_name, &st2, 0) < 0)
 191                                 goto fail;
 192                         if (S_ISDIR(st2.st_mode))
 193                                 is_dir = 1;
 194                         else
 195                                 is_dir = 0;
 196                 } else {
 197                         is_dir = 0;
 198                 }
 199
 200                 if (is_dir) {
 201                         type = EC_COMP_PARTIAL;
 202                         if (ec_asprintf(&comp_str, "%s%s/", input,
 203                                         &de->d_name[bname_len]) < 0)
 204                                 goto fail;
 205                         if (ec_asprintf(&disp_str, "%s/", de->d_name) < 0)
 206                                 goto fail;
 207                 } else {
 208                         type = EC_COMP_FULL;
 209                         if (ec_asprintf(&comp_str, "%s%s", input,
 210                                         &de->d_name[bname_len]) < 0)
 211                                 goto fail;
 212                         if (ec_asprintf(&disp_str, "%s", de->d_name) < 0)
 213                                 goto fail;
 214                 }
 215                 if (ec_comp_add_item(comp, gen_node, &item,
 216                                                 type, input, comp_str) < 0)
 217                         goto out;
 218
 219                 /* fix the display string: we don't want to display the full
 220                  * path. */
 221                 if (ec_comp_item_set_display(item, disp_str) < 0)
 222                         goto out;
 223
 224                 item = NULL;
 225                 ec_free(comp_str);
 226                 comp_str = NULL;
 227                 ec_free(disp_str);
 228                 disp_str = NULL;
 229         }
 230 out:
 231         ec_free(comp_str);
 232         ec_free(disp_str);
 233         ec_free(dname);
 234         ec_free(bname);
 235         if (dir != NULL)
 236                 node->closedir(dir);
 237
 238         return 0;
 239
 240 fail:
 241         ec_free(comp_str);
 242         ec_free(disp_str);
 243         ec_free(dname);
 244         ec_free(bname);
 245         if (dir != NULL)
 246                 node->closedir(dir);
 247
 248         return -1;
 249 }
 250
 251 static int
 252 ec_node_file_init_priv(struct ec_node *gen_node)
 253 {
 254         struct ec_node_file *node = (struct ec_node_file *)gen_node;
 255
 256         node->lstat = lstat;
 257         node->opendir = opendir;
 258         node->readdir = readdir;
 259         node->dirfd = dirfd;
 260         node->fstatat = fstatat;
 261
 262         return 0;
 263 }
 264
 265 static struct ec_node_type ec_node_file_type = {
 266         .name = "file",
 267         .parse = ec_node_file_parse,
 268         .complete = ec_node_file_complete,
 269         .size = sizeof(struct ec_node_file),
 270         .init_priv = ec_node_file_init_priv,
 271 };
 272
 273 EC_NODE_TYPE_REGISTER(ec_node_file_type);
 274
 275 /* LCOV_EXCL_START */
 276 static int
 277 test_lstat(const char *pathname, struct stat *buf)
 278 {
 279         if (!strcmp(pathname, "/tmp/toto/")) {
 280                 struct stat st = { .st_mode = S_IFDIR };
 281                 memcpy(buf, &st, sizeof(*buf));
 282                 return 0;
 283         }
 284
 285         errno = ENOENT;
 286         return -1;
 287 }
 288
 289 static DIR *
 290 test_opendir(const char *name)
 291 {
 292         int *p;
 293
 294         if (strcmp(name, "/tmp/toto/")) {
 295                 errno = ENOENT;
 296                 return NULL;
 297         }
 298
 299         p = malloc(sizeof(int));
 300         if (p)
 301                 *p = 0;
 302
 303         return (DIR *)p;
 304 }
 305
 306 static struct dirent *
 307 test_readdir(DIR *dirp)
 308 {
 309         static struct dirent de[] = {
 310                 { .d_type = DT_DIR, .d_name = ".." },
 311                 { .d_type = DT_DIR, .d_name = "." },
 312                 { .d_type = DT_REG, .d_name = "bar" },
 313                 { .d_type = DT_UNKNOWN, .d_name = "bar2" },
 314                 { .d_type = DT_REG, .d_name = "foo" },
 315                 { .d_type = DT_DIR, .d_name = "titi" },
 316                 { .d_type = DT_UNKNOWN, .d_name = "tutu" },
 317                 { .d_name = "" },
 318         };
 319         int *p = (int *)dirp;
 320         struct dirent *ret = &de[*p];
 321
 322         if (!strcmp(ret->d_name, ""))
 323                 return NULL;
 324
 325         *p = *p + 1;
 326
 327         return ret;
 328 }
 329
 330 static int
 331 test_closedir(DIR *dirp)
 332 {
 333         free(dirp);
 334         return 0;
 335 }
 336
 337 static int
 338 test_dirfd(DIR *dirp)
 339 {
 340         int *p = (int *)dirp;
 341         return *p;
 342 }
 343
 344 static int
 345 test_fstatat(int dirfd, const char *pathname, struct stat *buf,
 346         int flags)
 347 {
 348         (void)dirfd;
 349         (void)flags;
 350
 351         if (!strcmp(pathname, "bar2")) {
 352                 struct stat st = { .st_mode = S_IFREG };
 353                 memcpy(buf, &st, sizeof(*buf));
 354                 return 0;
 355         } else if (!strcmp(pathname, "tutu")) {
 356                 struct stat st = { .st_mode = S_IFDIR };
 357                 memcpy(buf, &st, sizeof(*buf));
 358                 return 0;
 359         }
 360
 361         errno = ENOENT;
 362         return -1;
 363 }
 364
 365 static int
 366 ec_node_file_override_functions(struct ec_node *gen_node)
 367 {
 368         struct ec_node_file *node = (struct ec_node_file *)gen_node;
 369
 370         node->lstat = test_lstat;
 371         node->opendir = test_opendir;
 372         node->readdir = test_readdir;
 373         node->closedir = test_closedir;
 374         node->dirfd = test_dirfd;
 375         node->fstatat = test_fstatat;
 376
 377         return 0;
 378 }
 379
 380 static int ec_node_file_testcase(void)
 381 {
 382         struct ec_node *node;
 383         int testres = 0;
 384
 385         node = ec_node("file", EC_NO_ID);
 386         if (node == NULL) {
 387                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 388                 return -1;
 389         }
 390         ec_node_file_override_functions(node);
 391
 392         /* any string matches */
 393         testres |= EC_TEST_CHECK_PARSE(node, 1, "foo");
 394         testres |= EC_TEST_CHECK_PARSE(node, 1, "/tmp/bar");
 395         testres |= EC_TEST_CHECK_PARSE(node, -1);
 396
 397         /* test completion */
 398         testres |= EC_TEST_CHECK_COMPLETE(node,
 399                 EC_NODE_ENDLIST,
 400                 EC_NODE_ENDLIST);
 401         testres |= EC_TEST_CHECK_COMPLETE(node,
 402                 "/tmp/toto/t", EC_NODE_ENDLIST,
 403                 EC_NODE_ENDLIST);
 404         testres |= EC_TEST_CHECK_COMPLETE_PARTIAL(node,
 405                 "/tmp/toto/t", EC_NODE_ENDLIST,
 406                 "/tmp/toto/titi/", "/tmp/toto/tutu/", EC_NODE_ENDLIST);
 407         testres |= EC_TEST_CHECK_COMPLETE(node,
 408                 "/tmp/toto/f", EC_NODE_ENDLIST,
 409                 "/tmp/toto/foo", EC_NODE_ENDLIST);
 410         testres |= EC_TEST_CHECK_COMPLETE(node,
 411                 "/tmp/toto/b", EC_NODE_ENDLIST,
 412                 "/tmp/toto/bar", "/tmp/toto/bar2", EC_NODE_ENDLIST);
 413
 414         ec_node_free(node);
 415
 416         return testres;
 417 }
 418 /* LCOV_EXCL_STOP */
 419
 420 static struct ec_test ec_node_file_test = {
 421         .name = "node_file",
 422         .test = ec_node_file_testcase,
 423 };
 424
 425 EC_TEST_REGISTER(ec_node_file_test);