Changeset 923c39e in mainline for uspace/lib/libc/generic/vfs/vfs.c


Ignore:
Timestamp:
2008-03-11T21:18:03Z (17 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cbd6545f
Parents:
f2ec8c8
Message:

Simplify the libc procedure needed to convert a user-supplied path to an
absolute canonical path.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libc/generic/vfs/vfs.c

    rf2ec8c8 r923c39e  
    4040#include <fcntl.h>
    4141#include <sys/stat.h>
     42#include <stdio.h>
    4243#include <sys/types.h>
    4344#include <ipc/ipc.h>
    … …  
    5859size_t cwd_len = 0;
    5960
    60 static char *absolutize(const char *path)
     61static char *absolutize(const char *path, size_t *retlen)
    6162{
    6263        char *ncwd_path;
    … …  
    8687        }
    8788        strcat(ncwd_path, path);
     89        if (!canonify(ncwd_path, retlen)) {
     90                futex_up(&cwd_futex);
     91                free(ncwd_path);
     92                return NULL;
     93        }
    8894        futex_up(&cwd_futex);
    8995        return ncwd_path;
    … …  
    103109        aid_t req;
    104110
    105         int dev_handle = 0;     /* TODO */
    106 
    107         char *mpa = absolutize(mp);
     111        dev_handle_t dev_handle = 0;    /* TODO */
     112
     113        size_t mpa_len;
     114        char *mpa = absolutize(mp, &mpa_len);
    108115        if (!mpa)
    109116                return ENOMEM;
    110         size_t mpc_len;
    111         char *mpc = canonify(mpa, &mpc_len);
    112         if (!mpc) {
    113                 free(mpa);
    114                 return EINVAL;
    115         }
    116117
    117118        futex_down(&vfs_phone_futex);
    … …  
    135136                return (int) rc;
    136137        }
    137         rc = ipc_data_write_start(vfs_phone, (void *)mpc, mpc_len);
     138        rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
    138139        if (rc != EOK) {
    139140                async_wait_for(req, NULL);
    … …  
    157158        aid_t req;
    158159       
    159         char *pa = absolutize(path);
     160        size_t pa_len;
     161        char *pa = absolutize(path, &pa_len);
    160162        if (!pa)
    161163                return ENOMEM;
    162         size_t pc_len;
    163         char *pc = canonify(pa, &pc_len);
    164         if (!pc) {
    165                 free(pa);
    166                 return EINVAL;
    167         }
    168164       
    169165        futex_down(&vfs_phone_futex);
    … …  
    179175        }
    180176        req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
    181         rc = ipc_data_write_start(vfs_phone, pc, pc_len);
     177        rc = ipc_data_write_start(vfs_phone, pa, pa_len);
    182178        if (rc != EOK) {
    183179                async_wait_for(req, NULL);
    … …  
    380376        aid_t req;
    381377       
    382         char *pa = absolutize(path);
     378        size_t pa_len;
     379        char *pa = absolutize(path, &pa_len);
    383380        if (!pa)
    384381                return ENOMEM;
    385         size_t pc_len;
    386         char *pc = canonify(pa, &pc_len);
    387         if (!pc) {
    388                 free(pa);
    389                 return EINVAL;
    390         }
    391382
    392383        futex_down(&vfs_phone_futex);
    … …  
    402393        }
    403394        req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
    404         rc = ipc_data_write_start(vfs_phone, pc, pc_len);
     395        rc = ipc_data_write_start(vfs_phone, pa, pa_len);
    405396        if (rc != EOK) {
    406397                async_wait_for(req, NULL);
    … …  
    423414        aid_t req;
    424415       
    425         char *pa = absolutize(path);
     416        size_t pa_len;
     417        char *pa = absolutize(path, &pa_len);
    426418        if (!pa)
    427419                return ENOMEM;
    428         size_t pc_len;
    429         char *pc = canonify(pa, &pc_len);
    430         if (!pc) {
    431                 free(pa);
    432                 return EINVAL;
    433         }
     420
    434421        futex_down(&vfs_phone_futex);
    435422        async_serialize_start();
    … …  
    444431        }
    445432        req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
    446         rc = ipc_data_write_start(vfs_phone, pc, pc_len);
     433        rc = ipc_data_write_start(vfs_phone, pa, pa_len);
    447434        if (rc != EOK) {
    448435                async_wait_for(req, NULL);
    … …  
    475462        aid_t req;
    476463       
    477         char *olda = absolutize(old);
     464        size_t olda_len;
     465        char *olda = absolutize(old, &olda_len);
    478466        if (!olda)
    479467                return ENOMEM;
    480         size_t oldc_len;
    481         char *oldc = canonify(olda, &oldc_len);
    482         if (!oldc) {
    483                 free(olda);
    484                 return EINVAL;
    485         }
    486         char *newa = absolutize(new);
     468
     469        size_t newa_len;
     470        char *newa = absolutize(new, &newa_len);
    487471        if (!newa) {
    488472                free(olda);
    489473                return ENOMEM;
    490474        }
    491         size_t newc_len;
    492         char *newc = canonify(newa, &newc_len);
    493         if (!newc) {
     475
     476        futex_down(&vfs_phone_futex);
     477        async_serialize_start();
     478        if (vfs_phone < 0) {
     479                res = vfs_connect();
     480                if (res < 0) {
     481                        async_serialize_end();
     482                        futex_up(&vfs_phone_futex);
     483                        free(olda);
     484                        free(newa);
     485                        return res;
     486                }
     487        }
     488        req = async_send_0(vfs_phone, VFS_RENAME, NULL);
     489        rc = ipc_data_write_start(vfs_phone, olda, olda_len);
     490        if (rc != EOK) {
     491                async_wait_for(req, NULL);
     492                async_serialize_end();
     493                futex_up(&vfs_phone_futex);
    494494                free(olda);
    495495                free(newa);
    496                 return EINVAL;
    497         }
    498 
    499         futex_down(&vfs_phone_futex);
    500         async_serialize_start();
    501         if (vfs_phone < 0) {
    502                 res = vfs_connect();
    503                 if (res < 0) {
    504                         async_serialize_end();
    505                         futex_up(&vfs_phone_futex);
    506                         free(olda);
    507                         free(newa);
    508                         return res;
    509                 }
    510         }
    511         req = async_send_0(vfs_phone, VFS_RENAME, NULL);
    512         rc = ipc_data_write_start(vfs_phone, oldc, oldc_len);
    513         if (rc != EOK) {
    514                 async_wait_for(req, NULL);
    515                 async_serialize_end();
    516                 futex_up(&vfs_phone_futex);
    517                 free(olda);
    518                 free(newa);
    519                 return (int) rc;
    520         }
    521         rc = ipc_data_write_start(vfs_phone, newc, newc_len);
     496                return (int) rc;
     497        }
     498        rc = ipc_data_write_start(vfs_phone, newa, newa_len);
    522499        if (rc != EOK) {
    523500                async_wait_for(req, NULL);
    … …  
    538515int chdir(const char *path)
    539516{
    540         char *pa = absolutize(path);
     517        size_t pa_len;
     518        char *pa = absolutize(path, &pa_len);
    541519        if (!pa)
    542520                return ENOMEM;
    543         size_t pc_len;
    544         char *pc = canonify(pa, &pc_len);
    545         if (!pc) {
    546                 free(pa);
    547                 return ENOENT;
    548         }
    549 
    550         DIR *d = opendir(pc);
     521
     522        DIR *d = opendir(pa);
    551523        if (!d) {
    552524                free(pa);
    … …  
    563535        }
    564536        cwd_dir = d;
    565         cwd_path = pc;
    566         cwd_len = pc_len;
     537        cwd_path = pa;
     538        cwd_len = pa_len;
    567539        futex_up(&cwd_futex);
    568540}
Note: See TracChangeset for help on using the changeset viewer.