Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 472c09d in mainline


Ignore:
Timestamp:
2010-02-03T15:18:40Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
b4cbef1
Parents:
28be7fa
Message:

more consistent naming scheme:

async_data_blob_receive → async_data_receive
async_data_string_receive → async_string_receive
CLIPBOARD_TAG_BLOB → CLIPBOARD_TAG_DATA

async_data_receive can now check the granularity of the received data
async_string_receive can now return the raw size of the received data

replace several common patterns of async_data_write_receive/_finalize
with a single async_data_receive/_string_receive (this greatly improves
code readability)

Location:
uspace
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/libc/generic/async.c

    r28be7fa r472c09d  
    13451345}
    13461346
    1347 /** Wrapper for receiving blobs via the async_data_write_*
     1347/** Wrapper for receiving binary data via the async_data_write_*
    13481348 *
    13491349 * This wrapper only makes it more comfortable to use async_data_write_*
    13501350 * functions to receive blobs.
    13511351 *
    1352  * @param blob     Pointer to data pointer (which should be later disposed
    1353  *                 by free()). If the operation fails, the pointer is not
    1354  *                 touched.
    1355  * @param max_size Maximum size (in bytes) of the blob to receive. 0 means
    1356  *                 no limit.
    1357  * @param received If not NULL, the size of the received data is stored here.
     1352 * @param data       Pointer to data pointer (which should be later disposed
     1353 *                   by free()). If the operation fails, the pointer is not
     1354 *                   touched.
     1355 * @param max_size   Maximum size (in bytes) of the data to receive. 0 means
     1356 *                   no limit.
     1357 * @param granulariy If non-zero, then the size of the received data has to
     1358 *                   be divisible by this value.
     1359 * @param received   If not NULL, the size of the received data is stored here.
    13581360 *
    13591361 * @return Zero on success or a value from @ref errno.h on failure.
    13601362 *
    13611363 */
    1362 int async_data_blob_receive(char **blob, const size_t max_size, size_t *received)
     1364int async_data_receive(void **data, const size_t max_size,
     1365    const size_t granularity, size_t *received)
    13631366{
    13641367        ipc_callid_t callid;
     
    13741377        }
    13751378       
    1376         char *data = (char *) malloc(size);
    1377         if (data == NULL) {
     1379        if ((granularity > 0) && ((size % granularity) != 0)) {
     1380                ipc_answer_0(callid, EINVAL);
     1381                return EINVAL;
     1382        }
     1383       
     1384        void *_data = malloc(size);
     1385        if (_data == NULL) {
    13781386                ipc_answer_0(callid, ENOMEM);
    13791387                return ENOMEM;
    13801388        }
    13811389       
    1382         int rc = async_data_write_finalize(callid, data, size);
     1390        int rc = async_data_write_finalize(callid, _data, size);
    13831391        if (rc != EOK) {
    1384                 free(data);
     1392                free(_data);
    13851393                return rc;
    13861394        }
    13871395       
    1388         *blob = data;
     1396        *data = _data;
    13891397        if (received != NULL)
    13901398                *received = size;
     
    14031411 * @param max_size Maximum size (in bytes) of the string to receive. 0 means
    14041412 *                 no limit.
     1413 * @param received If not NULL, the size of the received data is stored here.
    14051414 *
    14061415 * @return Zero on success or a value from @ref errno.h on failure.
    14071416 *
    14081417 */
    1409 int async_data_string_receive(char **str, const size_t max_size)
     1418int async_string_receive(char **str, const size_t max_size, size_t *received)
    14101419{
    14111420        ipc_callid_t callid;
     
    14351444        data[size] = 0;
    14361445        *str = data;
     1446        if (received != NULL)
     1447                *received = size;
     1448       
    14371449        return EOK;
    14381450}
  • uspace/lib/libc/generic/clipboard.c

    r28be7fa r472c09d  
    8484                clip_connect();
    8585               
    86                 aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_BLOB, NULL);
     86                aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL);
    8787                ipcarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
    8888                if (rc != EOK) {
     
    139139                        *str = sbuf;
    140140                        return EOK;
    141                 case CLIPBOARD_TAG_BLOB:
     141                case CLIPBOARD_TAG_DATA:
    142142                        sbuf = malloc(size + 1);
    143143                        if (sbuf == NULL)
  • uspace/lib/libc/include/async.h

    r28be7fa r472c09d  
    284284extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
    285285
    286 extern int async_data_blob_receive(char **, const size_t, size_t *);
    287 extern int async_data_string_receive(char **, const size_t);
     286extern int async_data_receive(void **, const size_t, const size_t, size_t *);
     287extern int async_string_receive(char **, const size_t, size_t *);
    288288
    289289#endif
  • uspace/lib/libc/include/ipc/clipboard.h

    r28be7fa r472c09d  
    4646typedef enum {
    4747        CLIPBOARD_TAG_NONE,
    48         CLIPBOARD_TAG_BLOB
     48        CLIPBOARD_TAG_DATA
    4949} clipboard_tag_t;
    5050
  • uspace/srv/clip/clip.c

    r28be7fa r472c09d  
    6464                ipc_answer_0(rid, EOK);
    6565                break;
    66         case CLIPBOARD_TAG_BLOB:
    67                 rc = async_data_blob_receive(&data, 0, &size);
     66        case CLIPBOARD_TAG_DATA:
     67                rc = async_data_receive(&data, 0, 0, &size);
    6868                if (rc != EOK) {
    6969                        ipc_answer_0(rid, rc);
     
    7878                clip_data = data;
    7979                clip_size = size;
    80                 clip_tag = CLIPBOARD_TAG_BLOB;
     80                clip_tag = CLIPBOARD_TAG_DATA;
    8181               
    8282                fibril_mutex_unlock(&clip_mtx);
     
    9797        /* Check for clipboard data tag compatibility */
    9898        switch (IPC_GET_ARG1(*request)) {
    99         case CLIPBOARD_TAG_BLOB:
     99        case CLIPBOARD_TAG_DATA:
    100100                if (!async_data_read_receive(&callid, &size)) {
    101101                        ipc_answer_0(callid, EINVAL);
     
    104104                }
    105105               
    106                 if (clip_tag != CLIPBOARD_TAG_BLOB) {
    107                         /* So far we only understand BLOB */
     106                if (clip_tag != CLIPBOARD_TAG_DATA) {
     107                        /* So far we only understand binary data */
    108108                        ipc_answer_0(callid, EOVERFLOW);
    109109                        ipc_answer_0(rid, EOVERFLOW);
  • uspace/srv/devmap/devmap.c

    r28be7fa r472c09d  
    396396         * Get driver name
    397397         */
    398         int rc = async_data_string_receive(&driver->name, DEVMAP_NAME_MAXLEN);
     398        int rc = async_string_receive(&driver->name, DEVMAP_NAME_MAXLEN, NULL);
    399399        if (rc != EOK) {
    400400                free(driver);
     
    510510        /* Get fqdn */
    511511        char *fqdn;
    512         int rc = async_data_string_receive(&fqdn, DEVMAP_NAME_MAXLEN);
     512        int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
    513513        if (rc != EOK) {
    514514                free(device);
     
    622622       
    623623        /* Get fqdn */
    624         int rc = async_data_string_receive(&fqdn, DEVMAP_NAME_MAXLEN);
     624        int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
    625625        if (rc != EOK) {
    626626                ipc_answer_0(iid, rc);
     
    683683       
    684684        /* Get device name */
    685         int rc = async_data_string_receive(&name, DEVMAP_NAME_MAXLEN);
     685        int rc = async_string_receive(&name, DEVMAP_NAME_MAXLEN, NULL);
    686686        if (rc != EOK) {
    687687                ipc_answer_0(iid, rc);
  • uspace/srv/fs/devfs/devfs_ops.c

    r28be7fa r472c09d  
    419419       
    420420        /* Accept the mount options */
    421         ipcarg_t retval = async_data_string_receive(&opts, 0);
     421        ipcarg_t retval = async_string_receive(&opts, 0, NULL);
    422422        if (retval != EOK) {
    423423                ipc_answer_0(rid, retval);
  • uspace/srv/fs/fat/fat_ops.c

    r28be7fa r472c09d  
    974974        uint16_t bps;
    975975        uint16_t rde;
    976         int rc;
    977 
    978         /* accept the mount options */
    979         ipc_callid_t callid;
    980         size_t size;
    981         if (!async_data_write_receive(&callid, &size)) {
    982                 ipc_answer_0(callid, EINVAL);
    983                 ipc_answer_0(rid, EINVAL);
    984                 return;
    985         }
    986         char *opts = malloc(size + 1);
    987         if (!opts) {
    988                 ipc_answer_0(callid, ENOMEM);
    989                 ipc_answer_0(rid, ENOMEM);
    990                 return;
    991         }
    992         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    993         if (retval != EOK) {
    994                 ipc_answer_0(rid, retval);
    995                 free(opts);
    996                 return;
    997         }
    998         opts[size] = '\0';
     976       
     977        /* Accept the mount options */
     978        char *opts;
     979        int rc = async_string_receive(&opts, 0, NULL);
     980       
     981        if (rc != EOK) {
     982                ipc_answer_0(rid, rc);
     983                return;
     984        }
    999985
    1000986        /* Check for option enabling write through. */
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r28be7fa r472c09d  
    439439{
    440440        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    441         int rc;
    442 
    443         /* accept the mount options */
    444         ipc_callid_t callid;
    445         size_t size;
    446         if (!async_data_write_receive(&callid, &size)) {
    447                 ipc_answer_0(callid, EINVAL);
    448                 ipc_answer_0(rid, EINVAL);
    449                 return;
    450         }
    451         char *opts = malloc(size + 1);
    452         if (!opts) {
    453                 ipc_answer_0(callid, ENOMEM);
    454                 ipc_answer_0(rid, ENOMEM);
    455                 return;
    456         }
    457         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
    458         if (retval != EOK) {
    459                 ipc_answer_0(rid, retval);
    460                 free(opts);
    461                 return;
    462         }
    463         opts[size] = '\0';
     441       
     442        /* Accept the mount options */
     443        char *opts;
     444        int rc = async_string_receive(&opts, 0, NULL);
     445       
     446        if (rc != EOK) {
     447                ipc_answer_0(rid, rc);
     448                return;
     449        }
    464450
    465451        /* Initialize TMPFS instance. */
  • uspace/srv/hid/console/console.c

    r28be7fa r472c09d  
    475475static void cons_write(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
    476476{
    477         ipc_callid_t callid;
     477        void *buf;
    478478        size_t size;
    479         if (!async_data_write_receive(&callid, &size)) {
    480                 ipc_answer_0(callid, EINVAL);
    481                 ipc_answer_0(rid, EINVAL);
     479        int rc = async_data_receive(&buf, 0, 0, &size);
     480       
     481        if (rc != EOK) {
     482                ipc_answer_0(rid, rc);
    482483                return;
    483484        }
    484        
    485         char *buf = (char *) malloc(size);
    486         if (buf == NULL) {
    487                 ipc_answer_0(callid, ENOMEM);
    488                 ipc_answer_0(rid, ENOMEM);
    489                 return;
    490         }
    491        
    492         (void) async_data_write_finalize(callid, buf, size);
    493485       
    494486        async_serialize_start();
  • uspace/srv/loader/main.c

    r28be7fa r472c09d  
    125125static void ldr_set_cwd(ipc_callid_t rid, ipc_call_t *request)
    126126{
    127         ipc_callid_t callid;
    128         size_t len;
    129        
    130         if (!async_data_write_receive(&callid, &len)) {
    131                 ipc_answer_0(callid, EINVAL);
    132                 ipc_answer_0(rid, EINVAL);
    133                 return;
    134         }
    135        
    136         cwd = malloc(len + 1);
    137         if (!cwd) {
    138                 ipc_answer_0(callid, ENOMEM);
    139                 ipc_answer_0(rid, ENOMEM);
    140                 return;
    141         }
    142        
    143         async_data_write_finalize(callid, cwd, len);
    144         cwd[len] = '\0';
    145        
    146         ipc_answer_0(rid, EOK);
     127        char *buf;
     128        int rc = async_string_receive(&buf, 0, NULL);
     129       
     130        if (rc == EOK) {
     131                if (cwd != NULL)
     132                        free(cwd);
     133               
     134                cwd = buf;
     135        }
     136       
     137        ipc_answer_0(rid, rc);
    147138}
    148139
     
    154145static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
    155146{
    156         ipc_callid_t callid;
    157         size_t len;
    158         char *name_buf;
    159        
    160         if (!async_data_write_receive(&callid, &len)) {
    161                 ipc_answer_0(callid, EINVAL);
    162                 ipc_answer_0(rid, EINVAL);
    163                 return;
    164         }
    165        
    166         name_buf = malloc(len + 1);
    167         if (!name_buf) {
    168                 ipc_answer_0(callid, ENOMEM);
    169                 ipc_answer_0(rid, ENOMEM);
    170                 return;
    171         }
    172        
    173         async_data_write_finalize(callid, name_buf, len);
    174         ipc_answer_0(rid, EOK);
    175        
    176         if (pathname != NULL) {
    177                 free(pathname);
    178                 pathname = NULL;
    179         }
    180        
    181         name_buf[len] = '\0';
    182         pathname = name_buf;
     147        char *buf;
     148        int rc = async_string_receive(&buf, 0, NULL);
     149       
     150        if (rc == EOK) {
     151                if (pathname != NULL)
     152                        free(pathname);
     153               
     154                pathname = buf;
     155        }
     156       
     157        ipc_answer_0(rid, rc);
    183158}
    184159
     
    190165static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
    191166{
    192         ipc_callid_t callid;
    193         size_t buf_size, arg_size;
    194         char *p;
    195         int n;
    196        
    197         if (!async_data_write_receive(&callid, &buf_size)) {
    198                 ipc_answer_0(callid, EINVAL);
    199                 ipc_answer_0(rid, EINVAL);
    200                 return;
    201         }
    202        
    203         if (arg_buf != NULL) {
    204                 free(arg_buf);
    205                 arg_buf = NULL;
    206         }
    207        
    208         if (argv != NULL) {
    209                 free(argv);
    210                 argv = NULL;
    211         }
    212        
    213         arg_buf = malloc(buf_size + 1);
    214         if (!arg_buf) {
    215                 ipc_answer_0(callid, ENOMEM);
    216                 ipc_answer_0(rid, ENOMEM);
    217                 return;
    218         }
    219        
    220         async_data_write_finalize(callid, arg_buf, buf_size);
    221        
    222         arg_buf[buf_size] = '\0';
    223        
    224         /*
    225          * Count number of arguments
    226          */
    227         p = arg_buf;
    228         n = 0;
    229         while (p < arg_buf + buf_size) {
    230                 arg_size = str_size(p);
    231                 p = p + arg_size + 1;
    232                 ++n;
    233         }
    234        
    235         /* Allocate argv */
    236         argv = malloc((n + 1) * sizeof(char *));
    237        
    238         if (argv == NULL) {
    239                 free(arg_buf);
    240                 ipc_answer_0(rid, ENOMEM);
    241                 return;
    242         }
    243 
    244         /*
    245          * Fill argv with argument pointers
    246          */
    247         p = arg_buf;
    248         n = 0;
    249         while (p < arg_buf + buf_size) {
    250                 argv[n] = p;
    251                
    252                 arg_size = str_size(p);
    253                 p = p + arg_size + 1;
    254                 ++n;
    255         }
    256        
    257         argc = n;
    258         argv[n] = NULL;
    259 
    260         ipc_answer_0(rid, EOK);
     167        char *buf;
     168        size_t buf_size;
     169        int rc = async_string_receive(&buf, 0, &buf_size);
     170       
     171        if (rc == EOK) {
     172                /*
     173                 * Count number of arguments
     174                 */
     175                char *cur = buf;
     176                int count = 0;
     177               
     178                while (cur < buf + buf_size) {
     179                        size_t arg_size = str_size(cur);
     180                        cur += arg_size + 1;
     181                        count++;
     182                }
     183               
     184                /*
     185                 * Allocate new argv
     186                 */
     187                char **_argv = (char **) malloc((count + 1) * sizeof(char *));
     188                if (_argv == NULL) {
     189                        free(buf);
     190                        ipc_answer_0(rid, ENOMEM);
     191                        return;
     192                }
     193               
     194                /*
     195                 * Fill the new argv with argument pointers
     196                 */
     197                cur = buf;
     198                count = 0;
     199                while (cur < buf + buf_size) {
     200                        _argv[count] = cur;
     201                       
     202                        size_t arg_size = str_size(cur);
     203                        cur += arg_size + 1;
     204                        count++;
     205                }
     206                _argv[count] = NULL;
     207               
     208                /*
     209                 * Copy temporary data to global variables
     210                 */
     211                if (arg_buf != NULL)
     212                        free(arg_buf);
     213               
     214                if (argv != NULL)
     215                        free(argv);
     216               
     217                argc = count;
     218                arg_buf = buf;
     219                argv = _argv;
     220        }
     221       
     222        ipc_answer_0(rid, rc);
    261223}
    262224
     
    268230static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
    269231{
    270         ipc_callid_t callid;
     232        void *buf;
    271233        size_t buf_size;
    272         if (!async_data_write_receive(&callid, &buf_size)) {
    273                 ipc_answer_0(callid, EINVAL);
    274                 ipc_answer_0(rid, EINVAL);
    275                 return;
    276         }
    277        
    278         if ((buf_size % sizeof(fdi_node_t)) != 0) {
    279                 ipc_answer_0(callid, EINVAL);
    280                 ipc_answer_0(rid, EINVAL);
    281                 return;
    282         }
    283        
    284         if (fil_buf != NULL) {
    285                 free(fil_buf);
    286                 fil_buf = NULL;
    287         }
    288        
    289         if (filv != NULL) {
    290                 free(filv);
    291                 filv = NULL;
    292         }
    293        
    294         fil_buf = malloc(buf_size);
    295         if (!fil_buf) {
    296                 ipc_answer_0(callid, ENOMEM);
    297                 ipc_answer_0(rid, ENOMEM);
    298                 return;
    299         }
    300        
    301         async_data_write_finalize(callid, fil_buf, buf_size);
    302        
    303         int count = buf_size / sizeof(fdi_node_t);
    304        
    305         /* Allocate filvv */
    306         filv = malloc((count + 1) * sizeof(fdi_node_t *));
    307        
    308         if (filv == NULL) {
    309                 free(fil_buf);
    310                 ipc_answer_0(rid, ENOMEM);
    311                 return;
    312         }
    313        
    314         /*
    315          * Fill filv with argument pointers
    316          */
    317         int i;
    318         for (i = 0; i < count; i++)
    319                 filv[i] = &fil_buf[i];
    320        
    321         filc = count;
    322         filv[count] = NULL;
     234        int rc = async_data_receive(&buf, 0, sizeof(fdi_node_t), &buf_size);
     235       
     236        if (rc == EOK) {
     237                int count = buf_size / sizeof(fdi_node_t);
     238               
     239                /*
     240                 * Allocate new filv
     241                 */
     242                fdi_node_t **_filv = (fdi_node_t *) malloc((count + 1) * sizeof(fdi_node_t *));
     243                if (_filv == NULL) {
     244                        free(buf);
     245                        ipc_answer_0(rid, ENOMEM);
     246                        return;
     247                }
     248               
     249                /*
     250                 * Fill the new filv with argument pointers
     251                 */
     252                int i;
     253                for (i = 0; i < count; i++)
     254                        _filv[i] = &((fdi_node_t *) buf)[i];
     255               
     256                _filv[count] = NULL;
     257               
     258                /*
     259                 * Copy temporary data to global variables
     260                 */
     261                if (fil_buf != NULL)
     262                        free(fil_buf);
     263               
     264                if (filv != NULL)
     265                        free(filv);
     266               
     267                filc = count;
     268                fil_buf = (fdi_node_t *) buf;
     269                filv = _filv;
     270        }
    323271       
    324272        ipc_answer_0(rid, EOK);
  • uspace/srv/vfs/vfs_ops.c

    r28be7fa r472c09d  
    266266       
    267267        /* We want the client to send us the mount point. */
    268         ipc_callid_t callid;
    269         size_t size;
    270         if (!async_data_write_receive(&callid, &size)) {
    271                 ipc_answer_0(callid, EINVAL);
    272                 ipc_answer_0(rid, EINVAL);
    273                 return;
    274         }
    275        
    276         /* Check whether size is reasonable wrt. the mount point. */
    277         if ((size < 1) || (size > MAX_PATH_LEN)) {
    278                 ipc_answer_0(callid, EINVAL);
    279                 ipc_answer_0(rid, EINVAL);
    280                 return;
    281         }
    282        
    283         /* Allocate buffer for the mount point data being received. */
    284         char *mp = malloc(size + 1);
    285         if (!mp) {
    286                 ipc_answer_0(callid, ENOMEM);
    287                 ipc_answer_0(rid, ENOMEM);
    288                 return;
    289         }
    290        
    291         /* Deliver the mount point. */
    292         ipcarg_t retval = async_data_write_finalize(callid, mp, size);
    293         if (retval != EOK) {
    294                 ipc_answer_0(rid, retval);
     268        char *mp;
     269        int rc = async_string_receive(&mp, MAX_PATH_LEN, NULL);
     270        if (rc != EOK) {
     271                ipc_answer_0(rid, rc);
     272                return;
     273        }
     274       
     275        /* Now we expect to receive the mount options. */
     276        char *opts;
     277        rc = async_string_receive(&opts, MAX_MNTOPTS_LEN, NULL);
     278        if (rc != EOK) {
    295279                free(mp);
    296                 return;
    297         }
    298         mp[size] = '\0';
    299        
    300         /* Now we expect to receive the mount options. */
    301         if (!async_data_write_receive(&callid, &size)) {
    302                 ipc_answer_0(callid, EINVAL);
    303                 ipc_answer_0(rid, EINVAL);
    304                 free(mp);
    305                 return;
    306         }
    307 
    308         /* Check the offered options size. */
    309         if (size > MAX_MNTOPTS_LEN) {
    310                 ipc_answer_0(callid, EINVAL);
    311                 ipc_answer_0(rid, EINVAL);
    312                 free(mp);
    313                 return;
    314         }
    315 
    316         /* Allocate buffer for the mount options. */
    317         char *opts = (char *) malloc(size + 1);
    318         if (!opts) {
    319                 ipc_answer_0(callid, ENOMEM);
    320                 ipc_answer_0(rid, ENOMEM);
    321                 free(mp);
    322                 return;
    323         }
    324 
    325         /* Deliver the mount options. */
    326         retval = async_data_write_finalize(callid, opts, size);
    327         if (retval != EOK) {
    328                 ipc_answer_0(rid, retval);
     280                ipc_answer_0(rid, rc);
     281                return;
     282        }
     283       
     284        /*
     285         * Now, we expect the client to send us data with the name of the file
     286         * system.
     287         */
     288        char *fs_name;
     289        rc = async_string_receive(&fs_name, FS_NAME_MAXLEN, NULL);
     290        if (rc != EOK) {
    329291                free(mp);
    330292                free(opts);
    331                 return;
    332         }
    333         opts[size] = '\0';
    334        
    335         /*
    336          * Now, we expect the client to send us data with the name of the file
    337          * system.
    338          */
    339         if (!async_data_write_receive(&callid, &size)) {
    340                 ipc_answer_0(callid, EINVAL);
    341                 ipc_answer_0(rid, EINVAL);
    342                 free(mp);
    343                 free(opts);
    344                 return;
    345         }
    346        
    347         /*
    348          * Don't receive more than is necessary for storing a full file system
    349          * name.
    350          */
    351         if ((size < 1) || (size > FS_NAME_MAXLEN)) {
    352                 ipc_answer_0(callid, EINVAL);
    353                 ipc_answer_0(rid, EINVAL);
    354                 free(mp);
    355                 free(opts);
    356                 return;
    357         }
    358        
    359         /*
    360          * Allocate buffer for file system name.
    361          */
    362         char *fs_name = (char *) malloc(size + 1);
    363         if (fs_name == NULL) {
    364                 ipc_answer_0(callid, ENOMEM);
    365                 ipc_answer_0(rid, ENOMEM);
    366                 free(mp);
    367                 free(opts);
    368                 return;
    369         }
    370        
    371         /* Deliver the file system name. */
    372         retval = async_data_write_finalize(callid, fs_name, size);
    373         if (retval != EOK) {
    374                 ipc_answer_0(rid, retval);
    375                 free(mp);
    376                 free(opts);
    377                 free(fs_name);
    378                 return;
    379         }
    380         fs_name[size] = '\0';
    381 
     293                ipc_answer_0(rid, rc);
     294                return;
     295        }
     296       
    382297        /*
    383298         * Wait for IPC_M_PING so that we can return an error if we don't know
     
    385300         */
    386301        ipc_call_t data;
    387         callid = async_get_call(&data);
     302        ipc_callid_t callid = async_get_call(&data);
    388303        if (IPC_GET_METHOD(data) != IPC_M_PING) {
    389304                ipc_answer_0(callid, ENOTSUP);
     
    442357         * Receive the mount point path.
    443358         */
    444         rc = async_data_string_receive(&mp, MAX_PATH_LEN);
     359        rc = async_string_receive(&mp, MAX_PATH_LEN, NULL);
    445360        if (rc != EOK)
    446361                ipc_answer_0(rid, rc);
     
    606521                lflag |= L_EXCLUSIVE;
    607522       
    608         ipc_callid_t callid;
    609         if (!async_data_write_receive(&callid, &len)) {
    610                 ipc_answer_0(callid, EINVAL);
    611                 ipc_answer_0(rid, EINVAL);
    612                 return;
    613         }
    614        
    615         char *path = malloc(len + 1);
    616         if (!path) {
    617                 ipc_answer_0(callid, ENOMEM);
    618                 ipc_answer_0(rid, ENOMEM);
    619                 return;
    620         }
    621        
    622         int rc;
    623         if ((rc = async_data_write_finalize(callid, path, len))) {
    624                 ipc_answer_0(rid, rc);
    625                 free(path);
    626                 return;
    627         }
    628         path[len] = '\0';
     523        char *path;
     524        int rc = async_string_receive(&path, 0, NULL);
     525        if (rc != EOK) {
     526                ipc_answer_0(rid, rc);
     527                return;
     528        }
    629529       
    630530        /*
     
    11201020void vfs_stat(ipc_callid_t rid, ipc_call_t *request)
    11211021{
    1122         size_t len;
     1022        char *path;
     1023        int rc = async_string_receive(&path, 0, NULL);
     1024        if (rc != EOK) {
     1025                ipc_answer_0(rid, rc);
     1026                return;
     1027        }
     1028       
    11231029        ipc_callid_t callid;
    1124 
    1125         if (!async_data_write_receive(&callid, &len)) {
    1126                 ipc_answer_0(callid, EINVAL);
    1127                 ipc_answer_0(rid, EINVAL);
    1128                 return;
    1129         }
    1130         char *path = malloc(len + 1);
    1131         if (!path) {
    1132                 ipc_answer_0(callid, ENOMEM);
    1133                 ipc_answer_0(rid, ENOMEM);
    1134                 return;
    1135         }
    1136         int rc;
    1137         if ((rc = async_data_write_finalize(callid, path, len))) {
    1138                 ipc_answer_0(rid, rc);
    1139                 free(path);
    1140                 return;
    1141         }
    1142         path[len] = '\0';
    1143 
    11441030        if (!async_data_read_receive(&callid, NULL)) {
    11451031                free(path);
     
    11871073{
    11881074        int mode = IPC_GET_ARG1(*request);
    1189 
    1190         size_t len;
    1191         ipc_callid_t callid;
    1192 
    1193         if (!async_data_write_receive(&callid, &len)) {
    1194                 ipc_answer_0(callid, EINVAL);
    1195                 ipc_answer_0(rid, EINVAL);
    1196                 return;
    1197         }
    1198         char *path = malloc(len + 1);
    1199         if (!path) {
    1200                 ipc_answer_0(callid, ENOMEM);
    1201                 ipc_answer_0(rid, ENOMEM);
    1202                 return;
    1203         }
    1204         int rc;
    1205         if ((rc = async_data_write_finalize(callid, path, len))) {
    1206                 ipc_answer_0(rid, rc);
    1207                 free(path);
    1208                 return;
    1209         }
    1210         path[len] = '\0';
    1211 
     1075       
     1076        char *path;
     1077        int rc = async_string_receive(&path, 0, NULL);
     1078        if (rc != EOK) {
     1079                ipc_answer_0(rid, rc);
     1080                return;
     1081        }
     1082       
    12121083        /* Ignore mode for now. */
    12131084        (void) mode;
     
    12241095{
    12251096        int lflag = IPC_GET_ARG1(*request);
    1226 
    1227         size_t len;
    1228         ipc_callid_t callid;
    1229 
    1230         if (!async_data_write_receive(&callid, &len)) {
    1231                 ipc_answer_0(callid, EINVAL);
    1232                 ipc_answer_0(rid, EINVAL);
    1233                 return;
    1234         }
    1235         char *path = malloc(len + 1);
    1236         if (!path) {
    1237                 ipc_answer_0(callid, ENOMEM);
    1238                 ipc_answer_0(rid, ENOMEM);
    1239                 return;
    1240         }
    1241         int rc;
    1242         if ((rc = async_data_write_finalize(callid, path, len))) {
    1243                 ipc_answer_0(rid, rc);
    1244                 free(path);
    1245                 return;
    1246         }
    1247         path[len] = '\0';
     1097       
     1098        char *path;
     1099        int rc = async_string_receive(&path, 0, NULL);
     1100        if (rc != EOK) {
     1101                ipc_answer_0(rid, rc);
     1102                return;
     1103        }
    12481104       
    12491105        fibril_rwlock_write_lock(&namespace_rwlock);
     
    12741130void vfs_rename(ipc_callid_t rid, ipc_call_t *request)
    12751131{
    1276         size_t olen, nlen;
    1277         ipc_callid_t callid;
    1278         int rc;
    1279 
    12801132        /* Retrieve the old path. */
    1281         if (!async_data_write_receive(&callid, &olen)) {
    1282                 ipc_answer_0(callid, EINVAL);
    1283                 ipc_answer_0(rid, EINVAL);
    1284                 return;
    1285         }
    1286         char *old = malloc(olen + 1);
    1287         if (!old) {
    1288                 ipc_answer_0(callid, ENOMEM);
    1289                 ipc_answer_0(rid, ENOMEM);
    1290                 return;
    1291         }
    1292         if ((rc = async_data_write_finalize(callid, old, olen))) {
    1293                 ipc_answer_0(rid, rc);
     1133        char *old;
     1134        int rc = async_string_receive(&old, 0, NULL);
     1135        if (rc != EOK) {
     1136                ipc_answer_0(rid, rc);
     1137                return;
     1138        }
     1139       
     1140        /* Retrieve the new path. */
     1141        char *new;
     1142        rc = async_string_receive(&new, 0, NULL);
     1143        if (rc != EOK) {
    12941144                free(old);
    1295                 return;
    1296         }
    1297         old[olen] = '\0';
    1298        
    1299         /* Retrieve the new path. */
    1300         if (!async_data_write_receive(&callid, &nlen)) {
    1301                 ipc_answer_0(callid, EINVAL);
    1302                 ipc_answer_0(rid, EINVAL);
    1303                 free(old);
    1304                 return;
    1305         }
    1306         char *new = malloc(nlen + 1);
    1307         if (!new) {
    1308                 ipc_answer_0(callid, ENOMEM);
    1309                 ipc_answer_0(rid, ENOMEM);
    1310                 free(old);
    1311                 return;
    1312         }
    1313         if ((rc = async_data_write_finalize(callid, new, nlen))) {
    1314                 ipc_answer_0(rid, rc);
    1315                 free(old);
    1316                 free(new);
    1317                 return;
    1318         }
    1319         new[nlen] = '\0';
    1320 
     1145                ipc_answer_0(rid, rc);
     1146                return;
     1147        }
     1148       
     1149        size_t olen;
     1150        size_t nlen;
    13211151        char *oldc = canonify(old, &olen);
    13221152        char *newc = canonify(new, &nlen);
    1323         if (!oldc || !newc) {
     1153       
     1154        if ((!oldc) || (!newc)) {
    13241155                ipc_answer_0(rid, EINVAL);
    13251156                free(old);
     
    13271158                return;
    13281159        }
     1160       
    13291161        oldc[olen] = '\0';
    13301162        newc[nlen] = '\0';
     1163       
    13311164        if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
    13321165            ((newc[str_length(oldc)] == '/') ||
     
    13491182        vfs_lookup_res_t new_par_lr;
    13501183        fibril_rwlock_write_lock(&namespace_rwlock);
     1184       
    13511185        /* Lookup the node belonging to the old file name. */
    13521186        rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
     
    13581192                return;
    13591193        }
     1194       
    13601195        vfs_node_t *old_node = vfs_node_get(&old_lr);
    13611196        if (!old_node) {
     
    13661201                return;
    13671202        }
     1203       
    13681204        /* Determine the path to the parent of the node with the new name. */
    13691205        char *parentc = str_dup(newc);
     
    13751211                return;
    13761212        }
     1213       
    13771214        char *lastsl = str_rchr(parentc + 1, '/');
    13781215        if (lastsl)
     
    13801217        else
    13811218                parentc[1] = '\0';
     1219       
    13821220        /* Lookup parent of the new file name. */
    13831221        rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
     
    13901228                return;
    13911229        }
     1230       
    13921231        /* Check whether linking to the same file system instance. */
    13931232        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
     
    13991238                return;
    14001239        }
     1240       
    14011241        /* Destroy the old link for the new name. */
    14021242        vfs_node_t *new_node = NULL;
    14031243        rc = vfs_lookup_internal(newc, L_UNLINK, &new_lr, NULL);
     1244       
    14041245        switch (rc) {
    14051246        case ENOENT:
     
    14261267                return;
    14271268        }
     1269       
    14281270        /* Create the new link for the new name. */
    14291271        rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
     
    14371279                return;
    14381280        }
     1281       
    14391282        fibril_mutex_lock(&nodes_mutex);
    14401283        old_node->lnkcnt++;
    14411284        fibril_mutex_unlock(&nodes_mutex);
     1285       
    14421286        /* Destroy the link for the old name. */
    14431287        rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
     
    14521296                return;
    14531297        }
     1298       
    14541299        fibril_mutex_lock(&nodes_mutex);
    14551300        old_node->lnkcnt--;
     
    14571302        fibril_rwlock_write_unlock(&namespace_rwlock);
    14581303        vfs_node_put(old_node);
     1304       
    14591305        if (new_node)
    14601306                vfs_node_put(new_node);
     1307       
    14611308        free(old);
    14621309        free(new);
Note: See TracChangeset for help on using the changeset viewer.