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

Changeset ab108be4 in mainline


Ignore:
Timestamp:
2010-04-17T01:26:05Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
9256ad29
Parents:
e1da7ec
Message:

fix several instances of possible NULL-pointer dereference and stale mutexes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/devmap/devmap.c

    re1da7ec rab108be4  
    172172               
    173173                *name = str_dup(fqdn);
    174                 if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
     174                if (*name == NULL) {
     175                        free(*ns_name);
     176                        return false;
     177                }
     178               
     179                if (str_cmp(*name, "") == 0) {
     180                        free(*name);
    175181                        free(*ns_name);
    176182                        return false;
     
    186192       
    187193        *name = str_dup(fqdn + slash_after);
    188         if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
     194        if (*name == NULL) {
    189195                free(*ns_name);
    190196                return false;
    191197        }
    192198       
     199        if (str_cmp(*name, "") == 0) {
     200                free(*name);
     201                free(*ns_name);
     202                return false;
     203        }
     204       
    193205        return true;
    194206}
     
    202214static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    203215{
    204         link_t *item = namespaces_list.next;
    205        
    206         while (item != &namespaces_list) {
    207                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     216        link_t *item;
     217        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
     218                devmap_namespace_t *namespace =
     219                    list_get_instance(item, devmap_namespace_t, namespaces);
    208220                if (str_cmp(namespace->name, name) == 0)
    209221                        return namespace;
    210                 item = item->next;
    211222        }
    212223       
     
    224235static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
    225236{
    226         link_t *item = namespaces_list.next;
    227        
    228         while (item != &namespaces_list) {
    229                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     237        link_t *item;
     238        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
     239                devmap_namespace_t *namespace =
     240                    list_get_instance(item, devmap_namespace_t, namespaces);
    230241                if (namespace->handle == handle)
    231242                        return namespace;
    232                
    233                 item = item->next;
    234243        }
    235244       
     
    246255    const char *name)
    247256{
    248         link_t *item = devices_list.next;
    249        
    250         while (item != &devices_list) {
    251                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
    252                 if ((str_cmp(device->namespace->name, ns_name) == 0) && (str_cmp(device->name, name) == 0))
     257        link_t *item;
     258        for (item = devices_list.next; item != &devices_list; item = item->next) {
     259                devmap_device_t *device =
     260                    list_get_instance(item, devmap_device_t, devices);
     261                if ((str_cmp(device->namespace->name, ns_name) == 0)
     262                    && (str_cmp(device->name, name) == 0))
    253263                        return device;
    254                 item = item->next;
    255264        }
    256265       
     
    268277static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
    269278{
    270         link_t *item = devices_list.next;
    271        
    272         while (item != &devices_list) {
    273                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
     279        link_t *item;
     280        for (item = devices_list.next; item != &devices_list; item = item->next) {
     281                devmap_device_t *device =
     282                    list_get_instance(item, devmap_device_t, devices);
    274283                if (device->handle == handle)
    275284                        return device;
    276                
    277                 item = item->next;
    278285        }
    279286       
     
    367374        list_remove(&(device->driver_devices));
    368375       
    369         free(device->namespace);
    370376        free(device->name);
    371377        free(device);
     
    386392        }
    387393       
    388         devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    389        
     394        devmap_driver_t *driver =
     395            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    390396        if (driver == NULL) {
    391397                ipc_answer_0(iid, ENOMEM);
     
    404410        }
    405411       
    406         /* Initialize mutex for list of devices owned by this driver */
     412        /*
     413         * Create connection to the driver
     414         */
     415        ipc_call_t call;
     416        ipc_callid_t callid = async_get_call(&call);
     417       
     418        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     419                free(driver->name);
     420                free(driver);
     421                ipc_answer_0(callid, ENOTSUP);
     422                ipc_answer_0(iid, ENOTSUP);
     423                return NULL;
     424        }
     425       
     426        driver->phone = IPC_GET_ARG5(call);
     427        ipc_answer_0(callid, EOK);
     428       
     429        /*
     430         * Initialize mutex for list of devices
     431         * owned by this driver
     432         */
    407433        fibril_mutex_initialize(&driver->devices_mutex);
    408434       
     
    411437         */
    412438        list_initialize(&driver->devices);
    413        
    414         /*
    415          * Create connection to the driver
    416          */
    417         ipc_call_t call;
    418         ipc_callid_t callid = async_get_call(&call);
    419        
    420         if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
    421                 ipc_answer_0(callid, ENOTSUP);
    422                
    423                 free(driver->name);
    424                 free(driver);
    425                 ipc_answer_0(iid, ENOTSUP);
    426                 return NULL;
    427         }
    428        
    429         driver->phone = IPC_GET_ARG5(call);
    430        
    431         ipc_answer_0(callid, EOK);
    432        
    433439        list_initialize(&(driver->drivers));
    434440       
     
    436442       
    437443        /* TODO:
    438          * check that no driver with name equal to driver->name is registered
     444         * Check that no driver with name equal to
     445         * driver->name is registered
    439446         */
    440447       
     
    482489        fibril_mutex_unlock(&drivers_list_mutex);
    483490       
    484         /* free name and driver */
     491        /* Free name and driver */
    485492        if (driver->name != NULL)
    486493                free(driver->name);
     
    503510       
    504511        /* Create new device entry */
    505         devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
     512        devmap_device_t *device =
     513            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    506514        if (device == NULL) {
    507515                ipc_answer_0(iid, ENOMEM);
     
    533541        devmap_namespace_t *namespace = devmap_namespace_create(ns_name);
    534542        free(ns_name);
    535         if (!namespace) {
     543        if (namespace == NULL) {
    536544                fibril_mutex_unlock(&devices_list_mutex);
     545                free(device->name);
    537546                free(device);
    538547                ipc_answer_0(iid, ENOMEM);
     
    545554        /* Check that device is not already registered */
    546555        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    547                 printf(NAME ": Device '%s/%s' already registered\n", device->namespace, device->name);
     556                printf("%s: Device '%s/%s' already registered\n", NAME,
     557                    device->namespace, device->name);
    548558                devmap_namespace_destroy(namespace);
    549559                fibril_mutex_unlock(&devices_list_mutex);
    550                 free(device->namespace);
    551560                free(device->name);
    552561                free(device);
     
    603612       
    604613        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
     614                fibril_mutex_unlock(&devices_list_mutex);
    605615                ipc_answer_0(callid, ENOENT);
    606616                return;
     
    668678                return;
    669679        }
     680       
     681        ipc_answer_1(iid, EOK, dev->handle);
     682       
    670683        fibril_mutex_unlock(&devices_list_mutex);
    671        
    672         ipc_answer_1(iid, EOK, dev->handle);
    673684        free(ns_name);
    674685        free(name);
     
    719730                return;
    720731        }
     732       
     733        ipc_answer_1(iid, EOK, namespace->handle);
     734       
    721735        fibril_mutex_unlock(&devices_list_mutex);
    722        
    723         ipc_answer_1(iid, EOK, namespace->handle);
    724736        free(name);
    725737}
     
    729741        fibril_mutex_lock(&devices_list_mutex);
    730742       
    731         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     743        devmap_namespace_t *namespace =
     744            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    732745        if (namespace == NULL) {
    733                 devmap_device_t *dev = devmap_device_find_handle(IPC_GET_ARG1(*icall));
     746                devmap_device_t *dev =
     747                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
    734748                if (dev == NULL)
    735749                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
     
    753767        fibril_mutex_lock(&devices_list_mutex);
    754768       
    755         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     769        devmap_namespace_t *namespace =
     770            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    756771        if (namespace == NULL)
    757772                ipc_answer_0(iid, EEXISTS);
     
    782797        size_t count = size / sizeof(dev_desc_t);
    783798        if (count != list_count(&namespaces_list)) {
     799                fibril_mutex_unlock(&devices_list_mutex);
    784800                ipc_answer_0(callid, EOVERFLOW);
    785801                ipc_answer_0(iid, EOVERFLOW);
     
    789805        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    790806        if (desc == NULL) {
     807                fibril_mutex_unlock(&devices_list_mutex);
    791808                ipc_answer_0(callid, ENOMEM);
    792809                ipc_answer_0(iid, ENOMEM);
     
    794811        }
    795812       
    796         link_t *item = namespaces_list.next;
     813        link_t *item;
    797814        size_t pos = 0;
    798         while (item != &namespaces_list) {
    799                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     815        for (item = namespaces_list.next; item != &namespaces_list;
     816            item = item->next) {
     817                devmap_namespace_t *namespace =
     818                    list_get_instance(item, devmap_namespace_t, namespaces);
    800819               
    801820                desc[pos].handle = namespace->handle;
    802821                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, namespace->name);
    803822                pos++;
    804                
    805                 item = item->next;
    806823        }
    807824       
     
    835852        fibril_mutex_lock(&devices_list_mutex);
    836853       
    837         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     854        devmap_namespace_t *namespace =
     855            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    838856        if (namespace == NULL) {
    839857                fibril_mutex_unlock(&devices_list_mutex);
     
    845863        size_t count = size / sizeof(dev_desc_t);
    846864        if (count != namespace->refcnt) {
     865                fibril_mutex_unlock(&devices_list_mutex);
    847866                ipc_answer_0(callid, EOVERFLOW);
    848867                ipc_answer_0(iid, EOVERFLOW);
     
    852871        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    853872        if (desc == NULL) {
     873                fibril_mutex_unlock(&devices_list_mutex);
    854874                ipc_answer_0(callid, ENOMEM);
    855875                ipc_answer_0(iid, EREFUSED);
     
    857877        }
    858878       
    859         link_t *item = devices_list.next;
     879        link_t *item;
    860880        size_t pos = 0;
    861         while (item != &devices_list) {
    862                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
     881        for (item = devices_list.next; item != &devices_list; item = item->next) {
     882                devmap_device_t *device =
     883                    list_get_instance(item, devmap_device_t, devices);
    863884               
    864885                if (device->namespace == namespace) {
     
    867888                        pos++;
    868889                }
    869                
    870                 item = item->next;
    871890        }
    872891       
     
    909928        }
    910929       
    911         devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
     930        devmap_device_t *device =
     931            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    912932        if (device == NULL) {
    913933                fibril_mutex_unlock(&null_devices_mutex);
     
    919939       
    920940        devmap_namespace_t *namespace = devmap_namespace_create("null");
    921         if (!namespace) {
     941        if (namespace == NULL) {
    922942                fibril_mutex_lock(&devices_list_mutex);
    923943                fibril_mutex_unlock(&null_devices_mutex);
     
    949969static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    950970{
     971        ipcarg_t i = IPC_GET_ARG1(*icall);
     972        if (i >= NULL_DEVICES) {
     973                ipc_answer_0(iid, ELIMIT);
     974                return;
     975        }
     976       
    951977        fibril_mutex_lock(&null_devices_mutex);
    952978       
    953         ipcarg_t i = IPC_GET_ARG1(*icall);
    954        
    955979        if (null_devices[i] == NULL) {
     980                fibril_mutex_unlock(&null_devices_mutex);
    956981                ipc_answer_0(iid, ENOENT);
    957982                return;
     
    965990       
    966991        fibril_mutex_unlock(&null_devices_mutex);
    967        
    968992        ipc_answer_0(iid, EOK);
    969993}
     
    11211145int main(int argc, char *argv[])
    11221146{
    1123         printf(NAME ": HelenOS Device Mapper\n");
     1147        printf("%s: HelenOS Device Mapper\n", NAME);
    11241148       
    11251149        if (!devmap_init()) {
    1126                 printf(NAME ": Error while initializing service\n");
     1150                printf("%s: Error while initializing service\n", NAME);
    11271151                return -1;
    11281152        }
     
    11361160                return -1;
    11371161       
    1138         printf(NAME ": Accepting connections\n");
     1162        printf("%s: Accepting connections\n", NAME);
    11391163        async_manager();
    11401164       
Note: See TracChangeset for help on using the changeset viewer.