Changeset 33b8d024 in mainline


Ignore:
Timestamp:
2018-01-16T20:38:46Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2467b41
Parents:
d39c46e0
Message:

Remove const qualifier from the argument of free() and realloc(),
as well as in numerous other variables that hold ownership of memory.

By convention, a pointer that holds ownership is _never_ qualified by const.
This is reflected in the standard type signature of free() and realloc().
Allowing const pointers to hold ownership may seem superficially convenient,
but is actually quite confusing to experienced C programmers.

Location:
uspace
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/compl.c

    rd39c46e0 r33b8d024  
    6969
    7070        /** Pointer inside list of directories */
    71         const char **path;
     71        const char *const *path;
    7272        /** If not @c NULL, should be freed in the end. */
    73         const char **path_list;
     73        char **path_list;
    7474        /** Current open directory */
    7575        DIR *dir;
    … …  
    219219                cs->path_list[0] = dirname;
    220220                cs->path_list[1] = NULL;
    221                 cs->path = cs->path_list;
     221                /* The second const ensures that we can't assign a const
     222                 * string to the non-const array. */
     223                cs->path = (const char *const *) cs->path_list;
    222224
    223225        } else if (cs->is_command) {

  • uspace/app/edit/search_impl.h

    rd39c46e0 r33b8d024  
    4343        /* Note: This structure is opaque for the user. */
    4444
    45         const wchar_t *pattern;
     45        wchar_t *pattern;
    4646        size_t pattern_length;
    4747        ssize_t *back_table;

  • uspace/app/mixerctl/mixerctl.c

    rd39c46e0 r33b8d024  
    4949static void print_levels(async_exch_t *exch)
    5050{
    51         const char* name = NULL;
     51        char* name = NULL;
    5252        unsigned count = 0;
    5353        errno_t ret = audio_mixer_get_info(exch, &name, &count);
    … …  
    5959
    6060        for (unsigned i = 0; i < count; ++i) {
    61                 const char *name = NULL;
     61                char *name = NULL;
    6262                unsigned levels = 0, current = 0;
    6363                errno_t ret =

  • uspace/app/wavplay/dplay.c

    rd39c46e0 r33b8d024  
    353353        }
    354354
    355         const char* info = NULL;
     355        char* info = NULL;
    356356        ret = audio_pcm_get_info_str(session, &info);
    357357        if (ret != EOK) {

  • uspace/app/wavplay/drec.c

    rd39c46e0 r33b8d024  
    195195        }
    196196
    197         const char* info = NULL;
     197        char* info = NULL;
    198198        ret = audio_pcm_get_info_str(session, &info);
    199199        if (ret != EOK) {

  • uspace/drv/bus/usb/vhc/hub/virthub.c

    rd39c46e0 r33b8d024  
    156156        dev->descriptors = &descriptors;
    157157        dev->address = 0;
    158         dev->name = str_dup(name);
    159         if (!dev->name)
     158
     159        char *n = str_dup(name);
     160        if (!n)
    160161                return ENOMEM;
    161162
    162163        hub_t *hub = malloc(sizeof(hub_t));
    163164        if (hub == NULL) {
    164                 free(dev->name);
     165                free(n);
    165166                return ENOMEM;
    166167        }
    167168
     169        dev->name = n;
    168170        hub_init(hub);
    169171        dev->device_data = hub;

  • uspace/drv/platform/amdm37x/main.c

    rd39c46e0 r33b8d024  
    4949typedef struct {
    5050        const char *name;
    51         match_id_t match_id;
     51        const char *id;
     52        int score;
    5253        hw_resource_list_t hw_resources;
    5354} amdm37x_fun_t;
    … …  
    133134{
    134135        .name = "ohci",
    135         .match_id = { .id = "usb/host=ohci", .score = 90 },
     136        .id = "usb/host=ohci",
     137        .score = 90,
    136138        .hw_resources = { .resources = ohci_res, .count = ARRAY_SIZE(ohci_res) }
    137139},
    138140{
    139141        .name = "ehci",
    140         .match_id = { .id = "usb/host=ehci", .score = 90 },
     142        .id = "usb/host=ehci",
     143        .score = 90,
    141144        .hw_resources = { .resources = ehci_res, .count = ARRAY_SIZE(ehci_res) }
    142145},
    143146{
    144147        .name = "fb",
    145         .match_id = { .id = "amdm37x&dispc", .score = 90 },
     148        .id = "amdm37x&dispc",
     149        .score = 90,
    146150        .hw_resources = { .resources = disp_res, .count = ARRAY_SIZE(disp_res) }
    147151},
    … …  
    174178       
    175179        /* Add match id */
    176         errno_t ret = ddf_fun_add_match_id(fnode,
    177             fun->match_id.id, fun->match_id.score);
     180        errno_t ret = ddf_fun_add_match_id(fnode, fun->id, fun->score);
    178181        if (ret != EOK) {
    179182                ddf_fun_destroy(fnode);

  • uspace/lib/c/generic/malloc.c

    rd39c46e0 r33b8d024  
    874874 *
    875875 */
    876 void *realloc(const void *addr, const size_t size)
     876void *realloc(void * const addr, const size_t size)
    877877{
    878878        if (size == 0) {
    … …  
    988988 *
    989989 */
    990 void free(const void *addr)
     990void free(void * const addr)
    991991{
    992992        if (addr == NULL)

  • uspace/lib/c/include/ipc/devman.h

    rd39c46e0 r33b8d024  
    7474        /** Id of device model.
    7575         */
    76         const char *id;
     76        char *id;
    7777        /** Relevancy of device-to-driver match.
    7878         * The higher is the product of scores specified for the device by the bus driver and by the leaf driver,

  • uspace/lib/c/include/malloc.h

    rd39c46e0 r33b8d024  
    3838#include <stddef.h>
    3939
    40 extern void *malloc(const size_t size)
     40extern void *malloc(size_t size)
    4141    __attribute__((malloc));
    42 extern void *calloc(const size_t nmemb, const size_t size)
     42extern void *calloc(size_t nmemb, size_t size)
    4343    __attribute__((malloc));
    44 extern void *memalign(const size_t align, const size_t size)
     44extern void *memalign(size_t align, size_t size)
    4545    __attribute__((malloc));
    46 extern void *realloc(const void *addr, const size_t size)
     46extern void *realloc(void *addr, size_t size)
    4747    __attribute__((warn_unused_result));
    48 extern void free(const void *addr);
     48extern void free(void *addr);
    4949extern void *heap_check(void);
    5050

  • uspace/lib/drv/generic/private/driver.h

    rd39c46e0 r33b8d024  
    5757       
    5858        /** Device name */
    59         const char *name;
     59        char *name;
    6060       
    6161        /** Driver-specific data associated with this device */
    … …  
    8484       
    8585        /** Function name */
    86         const char *name;
     86        char *name;
    8787       
    8888        /** List of device ids for driver matching */

  • uspace/lib/drv/generic/remote_audio_mixer.c

    rd39c46e0 r33b8d024  
    9494 * @return Error code.
    9595 */
    96 errno_t audio_mixer_get_info(async_exch_t *exch, const char **name, unsigned *items)
     96errno_t audio_mixer_get_info(async_exch_t *exch, char **name, unsigned *items)
    9797{
    9898        if (!exch)
    … …  
    131131 */
    132132errno_t audio_mixer_get_item_info(async_exch_t *exch, unsigned item,
    133     const char **name, unsigned *levels)
     133    char **name, unsigned *levels)
    134134{
    135135        if (!exch)

  • uspace/lib/drv/generic/remote_audio_pcm.c

    rd39c46e0 r33b8d024  
    184184 * @note Caller is responsible for freeing newly allocated memory.
    185185 */
    186 errno_t audio_pcm_get_info_str(audio_pcm_sess_t *sess, const char **name)
     186errno_t audio_pcm_get_info_str(audio_pcm_sess_t *sess, char **name)
    187187{
    188188        if (!name)

  • uspace/lib/drv/include/audio_mixer_iface.h

    rd39c46e0 r33b8d024  
    4343#include "ddf/driver.h"
    4444
    45 errno_t audio_mixer_get_info(async_exch_t *, const char **, unsigned *);
     45errno_t audio_mixer_get_info(async_exch_t *, char **, unsigned *);
    4646errno_t audio_mixer_get_item_info(async_exch_t *, unsigned,
    47     const char **, unsigned *);
     47    char **, unsigned *);
    4848errno_t audio_mixer_get_item_level(async_exch_t *, unsigned, unsigned *);
    4949errno_t audio_mixer_set_item_level(async_exch_t *, unsigned, unsigned);

  • uspace/lib/drv/include/audio_pcm_iface.h

    rd39c46e0 r33b8d024  
    8080void audio_pcm_close(audio_pcm_sess_t *);
    8181
    82 errno_t audio_pcm_get_info_str(audio_pcm_sess_t *, const char **);
     82errno_t audio_pcm_get_info_str(audio_pcm_sess_t *, char **);
    8383errno_t audio_pcm_test_format(audio_pcm_sess_t *, unsigned *, unsigned *,
    8484    pcm_sample_format_t *);

  • uspace/lib/hound/include/hound/client.h

    rd39c46e0 r33b8d024  
    5757
    5858errno_t hound_context_get_available_targets(hound_context_t *hound,
    59     const char ***names, size_t *count);
     59    char ***names, size_t *count);
    6060errno_t hound_context_get_connected_targets(hound_context_t *hound,
    61     const char ***names, size_t *count);
     61    char ***names, size_t *count);
    6262
    6363errno_t hound_context_connect_target(hound_context_t *hound, const char* target);

  • uspace/lib/hound/include/hound/protocol.h

    rd39c46e0 r33b8d024  
    6565errno_t hound_service_unregister_context(hound_sess_t *sess, hound_context_id_t id);
    6666
    67 errno_t hound_service_get_list(hound_sess_t *sess, const char ***ids, size_t *count,
     67errno_t hound_service_get_list(hound_sess_t *sess, char ***ids, size_t *count,
    6868    int flags, const char *connection);
    6969
    … …  
    7777 */
    7878static inline errno_t hound_service_get_list_all(hound_sess_t *sess,
    79     const char ***ids, size_t *count, int flags)
     79    char ***ids, size_t *count, int flags)
    8080{
    8181        return hound_service_get_list(sess, ids, count, flags, NULL);
    … …  
    106106        bool (*is_record_context)(void *, hound_context_id_t);
    107107        /** Get string identifiers of specified objects */
    108         errno_t (*get_list)(void *, const char ***, size_t *, const char *, int);
     108        errno_t (*get_list)(void *, char ***, size_t *, const char *, int);
    109109        /** Create connection between source and sink */
    110110        errno_t (*connect)(void *, const char *, const char *);

  • uspace/lib/hound/src/client.c

    rd39c46e0 r33b8d024  
    7676        hound_sess_t *session;
    7777        /** context name, reported to the daemon */
    78         const char *name;
     78        char *name;
    7979        /** True if the instance is record context */
    8080        bool record;
    … …  
    196196 */
    197197errno_t hound_context_get_available_targets(hound_context_t *hound,
    198     const char ***names, size_t *count)
     198    char ***names, size_t *count)
    199199{
    200200        assert(hound);
    … …  
    213213 */
    214214errno_t hound_context_get_connected_targets(hound_context_t *hound,
    215     const char ***names, size_t *count)
     215    char ***names, size_t *count)
    216216{
    217217        assert(hound);
    … …  
    237237        assert(target);
    238238
    239         const char **tgt = NULL;
     239        char **tgt = NULL;
    240240        size_t count = 1;
    241241        errno_t ret = EOK;

  • uspace/lib/hound/src/protocol.c

    rd39c46e0 r33b8d024  
    173173 * @retval Error code.
    174174 */
    175 errno_t hound_service_get_list(hound_sess_t *sess, const char ***ids, size_t *count,
     175errno_t hound_service_get_list(hound_sess_t *sess, char ***ids, size_t *count,
    176176    int flags, const char *connection)
    177177{
    … …  
    206206
    207207        /* Start receiving names */
    208         const char **names = NULL;
     208        char **names = NULL;
    209209        if (name_count) {
    210210                size_t *sizes = calloc(name_count, sizeof(size_t));
    … …  
    446446                        }
    447447
    448                         const char **list = NULL;
     448                        char **list = NULL;
    449449                        const int flags = IPC_GET_ARG1(call);
    450450                        size_t count = IPC_GET_ARG2(call);

  • uspace/lib/nic/include/nic.h

    rd39c46e0 r33b8d024  
    5757        nic_wv_id_t id;
    5858        nic_wv_type_t type;
    59         const void *data;
     59        void *data;
    6060        size_t length;
    6161        struct nic_wol_virtue *next;

  • uspace/lib/posix/source/stdio/scanf.c

    rd39c46e0 r33b8d024  
    625625
    626626                                const char *cur_borrowed = NULL;
     627                                char *cur_duplicated = NULL;
    627628                                const char *cur_limited = NULL;
    628                                 char *cur_updated = NULL;
     629                                const char *cur_updated = NULL;
    629630
    630631                                /* Borrow the cursor. Until it is returned to the provider
    … …  
    637638                                 * than allowed by width. */
    638639                                if (width != -1) {
    639                                         cur_limited = posix_strndup(cur_borrowed, width);
     640                                        cur_duplicated = posix_strndup(cur_borrowed, width);
     641                                        cur_limited = cur_duplicated;
    640642                                } else {
    641643                                        cur_limited = cur_borrowed;
    642644                                }
    643                                 cur_updated = (char *) cur_limited;
     645                                cur_updated = cur_limited;
    644646
    645647                                long long sres = 0;
    … …  
    648650                                /* Try to convert the integer. */
    649651                                if (int_conv_unsigned) {
    650                                         ures = strtoull(cur_limited, &cur_updated, int_conv_base);
     652                                        ures = strtoull(cur_limited, (char **) &cur_updated, int_conv_base);
    651653                                } else {
    652                                         sres = strtoll(cur_limited, &cur_updated, int_conv_base);
     654                                        sres = strtoll(cur_limited, (char **) &cur_updated, int_conv_base);
    653655                                }
    654656
    655657                                /* Update the cursor so it can be returned to the provider. */
    656658                                cur_borrowed += cur_updated - cur_limited;
    657                                 if (width != -1 && cur_limited != NULL) {
     659                                if (cur_duplicated != NULL) {
    658660                                        /* Deallocate duplicated part of the cursor view. */
    659                                         free(cur_limited);
     661                                        free(cur_duplicated);
    660662                                }
    661663                                cur_limited = NULL;
    662664                                cur_updated = NULL;
     665                                cur_duplicated = NULL;
    663666                                /* Return the cursor to the provider. Input consistency is again
    664667                                 * the job of the provider, so we can report errors from
    … …  
    797800                                const char *cur_borrowed = NULL;
    798801                                const char *cur_limited = NULL;
    799                                 char *cur_updated = NULL;
     802                                char *cur_duplicated = NULL;
     803                                const char *cur_updated = NULL;
    800804
    801805                                /* Borrow the cursor. Until it is returned to the provider
    … …  
    808812                                 * than allowed by width. */
    809813                                if (width != -1) {
    810                                         cur_limited = posix_strndup(cur_borrowed, width);
     814                                        cur_duplicated = posix_strndup(cur_borrowed, width);
     815                                        cur_limited = cur_duplicated;
    811816                                } else {
    812817                                        cur_limited = cur_borrowed;
    813818                                }
    814                                 cur_updated = (char *) cur_limited;
     819                                cur_updated = cur_limited;
    815820
    816821                                float fres = 0.0;
    … …  
    821826                                switch (length_mod) {
    822827                                case LMOD_NONE:
    823                                         fres = posix_strtof(cur_limited, &cur_updated);
     828                                        fres = posix_strtof(cur_limited, (char **) &cur_updated);
    824829                                        break;
    825830                                case LMOD_l:
    826                                         dres = posix_strtod(cur_limited, &cur_updated);
     831                                        dres = posix_strtod(cur_limited, (char **) &cur_updated);
    827832                                        break;
    828833                                case LMOD_L:
    829                                         ldres = posix_strtold(cur_limited, &cur_updated);
     834                                        ldres = posix_strtold(cur_limited, (char **) &cur_updated);
    830835                                        break;
    831836                                default:
    … …  
    835840                                /* Update the cursor so it can be returned to the provider. */
    836841                                cur_borrowed += cur_updated - cur_limited;
    837                                 if (width != -1 && cur_limited != NULL) {
     842                                if (cur_duplicated != NULL) {
    838843                                        /* Deallocate duplicated part of the cursor view. */
    839                                         free(cur_limited);
     844                                        free(cur_duplicated);
    840845                                }
    841846                                cur_limited = NULL;

  • uspace/lib/usbdev/include/usb/dev/alternate_ifaces.h

    rd39c46e0 r33b8d024  
    5959typedef struct {
    6060        /** Array of alternate interfaces descriptions. */
    61         const usb_alternate_interface_descriptors_t *alternatives;
     61        usb_alternate_interface_descriptors_t *alternatives;
    6262        /** Size of @c alternatives array. */
    6363        size_t alternative_count;

  • uspace/lib/usbdev/include/usb/dev/device.h

    rd39c46e0 r33b8d024  
    5151        usb_standard_device_descriptor_t device;
    5252        /** Full configuration descriptor of current configuration. */
    53         const void *full_config;
     53        void *full_config;
    5454        size_t full_config_size;
    5555} usb_device_descriptors_t;

  • uspace/lib/usbdev/include/usb/dev/request.h

    rd39c46e0 r33b8d024  
    7070    void *, size_t, size_t *);
    7171errno_t usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
    72     int, const void **, size_t *);
     72    int, void **, size_t *);
    7373errno_t usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
    7474    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, const void *, size_t);

  • uspace/lib/usbdev/src/devpoll.c

    rd39c46e0 r33b8d024  
    8080{
    8181        assert(arg);
    82         const polling_data_t *data = arg;
     82        polling_data_t *data = arg;
    8383        /* Helper to reduce typing. */
    8484        const usb_device_auto_polling_t *params = &data->auto_polling;

  • uspace/lib/usbdev/src/recognise.c

    rd39c46e0 r33b8d024  
    6161 */
    6262static errno_t usb_add_match_id(match_id_list_t *matches, int score,
    63     const char *match_str)
     63    char *match_str)
    6464{
    6565        assert(matches);

  • uspace/lib/usbdev/src/request.c

    rd39c46e0 r33b8d024  
    475475errno_t usb_request_get_full_configuration_descriptor_alloc(
    476476    usb_pipe_t *pipe, int index,
    477     const void **descriptor_ptr, size_t *descriptor_size)
     477    void **descriptor_ptr, size_t *descriptor_size)
    478478{
    479479        errno_t rc;

  • uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h

    rd39c46e0 r33b8d024  
    105105    void *arg
    106106);
    107 void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance);
     107void usb_transfer_batch_destroy(usb_transfer_batch_t *instance);
    108108
    109109void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,

  • uspace/lib/usbhost/src/usb_transfer_batch.c

    rd39c46e0 r33b8d024  
    9494 * @param[in] instance Batch structure to use.
    9595 */
    96 void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance)
     96void usb_transfer_batch_destroy(usb_transfer_batch_t *instance)
    9797{
    9898        if (!instance)

  • uspace/lib/usbvirt/include/usbvirt/device.h

    rd39c46e0 r33b8d024  
    154154        usb_standard_configuration_descriptor_t *descriptor;
    155155        /** Array of extra data. */
    156         const usbvirt_device_configuration_extras_t *extra;
     156        usbvirt_device_configuration_extras_t *extra;
    157157        /** Length of @c extra array. */
    158158        size_t extra_count;

  • uspace/srv/audio/hound/audio_data.c

    rd39c46e0 r33b8d024  
    3636#include <macros.h>
    3737#include <stdlib.h>
     38#include <str.h>
    3839
    3940#include "audio_data.h"
    … …  
    5051    pcm_format_t format)
    5152{
    52         audio_data_t *adata = malloc(sizeof(audio_data_t));
     53        audio_data_t *adata = malloc(sizeof(audio_data_t) + size);
    5354        if (adata) {
    5455                unsigned overflow = size % pcm_format_frame_size(&format);
    … …  
    5657                        log_warning("Data not a multiple of frame size, "
    5758                            "clipping.");
    58 
    59                 adata->data = data;
     59                uint8_t *d = ((uint8_t *)adata) + offsetof(audio_data_t, data);
     60                memcpy(d, data, size);
    6061                adata->size = size - overflow;
    6162                adata->format = format;
    … …  
    8687        atomic_count_t refc = atomic_predec(&adata->refcount);
    8788        if (refc == 0) {
    88                 free(adata->data);
    8989                free(adata);
    9090        }

  • uspace/srv/audio/hound/audio_data.h

    rd39c46e0 r33b8d024  
    4545/** Reference counted audio buffer */
    4646typedef struct {
    47         /** Audio data */
    48         const void *data;
    4947        /** Size of the buffer pointer to by data */
    5048        size_t size;
    … …  
    5351        /** Reference counter */
    5452        atomic_t refcount;
     53        /** Audio data */
     54        const uint8_t data[];
    5555} audio_data_t;
    5656

  • uspace/srv/audio/hound/audio_sink.h

    rd39c46e0 r33b8d024  
    5454        list_t connections;
    5555        /** Sink's name */
    56         const char *name;
     56        char *name;
    5757        /** Consumes data in this format */
    5858        pcm_format_t format;

  • uspace/srv/audio/hound/audio_source.c

    rd39c46e0 r33b8d024  
    9696 * @return Error code.
    9797 */
    98 errno_t audio_source_push_data(audio_source_t *source, const void *data,
     98errno_t audio_source_push_data(audio_source_t *source, void *data,
    9999    size_t size)
    100100{

  • uspace/srv/audio/hound/audio_source.h

    rd39c46e0 r33b8d024  
    4949        list_t connections;
    5050        /** String identifier */
    51         const char *name;
     51        char *name;
    5252        /** audio data format */
    5353        pcm_format_t format;
    … …  
    7575    const pcm_format_t *f);
    7676void audio_source_fini(audio_source_t *source);
    77 errno_t audio_source_push_data(audio_source_t *source, const void *data,
     77errno_t audio_source_push_data(audio_source_t *source, void *data,
    7878    size_t size);
    7979static inline const pcm_format_t *audio_source_format(const audio_source_t *s)

  • uspace/srv/audio/hound/hound.c

    rd39c46e0 r33b8d024  
    414414 * @return Error code.
    415415 */
    416 errno_t hound_list_sources(hound_t *hound, const char ***list, size_t *size)
     416errno_t hound_list_sources(hound_t *hound, char ***list, size_t *size)
    417417{
    418418        assert(hound);
    … …  
    428428                return EOK;
    429429        }
    430         const char **names = calloc(count, sizeof(char *));
     430        char **names = calloc(count, sizeof(char *));
    431431        errno_t ret = names ? EOK : ENOMEM;
    432432        for (unsigned long i = 0; i < count && ret == EOK; ++i) {
    … …  
    456456 * @return Error code.
    457457 */
    458 errno_t hound_list_sinks(hound_t *hound, const char ***list, size_t *size)
     458errno_t hound_list_sinks(hound_t *hound, char ***list, size_t *size)
    459459{
    460460        assert(hound);
    … …  
    470470                return EOK;
    471471        }
    472         const char **names = calloc(count, sizeof(char *));
     472        char **names = calloc(count, sizeof(char *));
    473473        errno_t ret = names ? EOK : ENOMEM;
    474474        for (size_t i = 0; i < count && ret == EOK; ++i) {

  • uspace/srv/audio/hound/hound.h

    rd39c46e0 r33b8d024  
    7373errno_t hound_add_source(hound_t *hound, audio_source_t *source);
    7474errno_t hound_add_sink(hound_t *hound, audio_sink_t *sink);
    75 errno_t hound_list_sources(hound_t *hound, const char ***list, size_t *size);
    76 errno_t hound_list_sinks(hound_t *hound, const char ***list, size_t *size);
     75errno_t hound_list_sources(hound_t *hound, char ***list, size_t *size);
     76errno_t hound_list_sinks(hound_t *hound, char ***list, size_t *size);
    7777errno_t hound_list_connections(hound_t *hound, const char ***sources,
    7878    const char ***sinks, size_t *size);

  • uspace/srv/audio/hound/iface.c

    rd39c46e0 r33b8d024  
    8686}
    8787
    88 static errno_t iface_get_list(void *server, const char ***list, size_t *size,
     88static errno_t iface_get_list(void *server, char ***list, size_t *size,
    8989    const char *connection, int flags)
    9090{

  • uspace/srv/devman/devman.h

    rd39c46e0 r33b8d024  
    8080        char *name;
    8181        /** Path to the driver's binary. */
    82         const char *binary_path;
     82        char *binary_path;
    8383        /** List of device ids for device-to-driver matching. */
    8484        match_id_list_t match_ids;
Note: See TracChangeset for help on using the changeset viewer.