Ignore:
Timestamp:
2011-05-12T16:49:44Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f36787d7
Parents:
e80329d6 (diff), 750636a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/adt/measured_strings.c

    re80329d6 rb5e68c8  
    4141#include <unistd.h>
    4242#include <errno.h>
    43 #include <err.h>
    4443#include <async.h>
    4544
    … …  
    5655 *                      appended with the terminating zero ('\0') character
    5756 *                      otherwise.
    58  * @returns             The new bundled character string with measured length.
    59  * @returns             NULL if there is not enough memory left.
    60  */
    61 measured_string_ref
    62 measured_string_create_bulk(const char *string, size_t length)
    63 {
    64         measured_string_ref new;
     57 * @return              The new bundled character string with measured length.
     58 * @return              NULL if there is not enough memory left.
     59 */
     60measured_string_t *
     61measured_string_create_bulk(const uint8_t *string, size_t length)
     62{
     63        measured_string_t *new;
    6564
    6665        if (length == 0) {
    … …  
    6867                        length++;
    6968        }
    70         new = (measured_string_ref) malloc(sizeof(measured_string_t) +
    71             (sizeof(char) * (length + 1)));
     69        new = (measured_string_t *) malloc(sizeof(measured_string_t) +
     70            (sizeof(uint8_t) * (length + 1)));
    7271        if (!new)
    7372                return NULL;
    7473
    7574        new->length = length;
    76         new->value = ((char *) new) + sizeof(measured_string_t);
    77         // append terminating zero explicitly - to be safe
     75        new->value = ((uint8_t *) new) + sizeof(measured_string_t);
     76        /* Append terminating zero explicitly - to be safe */
    7877        memcpy(new->value, string, new->length);
    7978        new->value[new->length] = '\0';
    … …  
    8584 *
    8685 * @param[in] source    The source measured string to be copied.
    87  * @returns             The copy of the given measured string.
    88  * @returns             NULL if the source parameter is NULL.
    89  * @returns             NULL if there is not enough memory left.
    90  */
    91 measured_string_ref measured_string_copy(measured_string_ref source)
    92 {
    93         measured_string_ref new;
     86 * @return              The copy of the given measured string.
     87 * @return              NULL if the source parameter is NULL.
     88 * @return              NULL if there is not enough memory left.
     89 */
     90measured_string_t *measured_string_copy(measured_string_t *source)
     91{
     92        measured_string_t *new;
    9493
    9594        if (!source)
    9695                return NULL;
    9796
    98         new = (measured_string_ref) malloc(sizeof(measured_string_t));
     97        new = (measured_string_t *) malloc(sizeof(measured_string_t));
    9998        if (new) {
    100                 new->value = (char *) malloc(source->length + 1);
     99                new->value = (uint8_t *) malloc(source->length + 1);
    101100                if (new->value) {
    102101                        new->length = source->length;
    … …  
    121120 *                      actual character strings.
    122121 *  @param[in] count    The size of the measured strings array.
    123  *  @returns            EOK on success.
    124  *  @returns            EINVAL if the strings or data parameter is NULL.
    125  *  @returns            EINVAL if the count parameter is zero (0).
    126  *  @returns            EINVAL if the sent array differs in size.
    127  *  @returns            EINVAL if there is inconsistency in sent measured
     122 *  @return             EOK on success.
     123 *  @return             EINVAL if the strings or data parameter is NULL.
     124 *  @return             EINVAL if the count parameter is zero (0).
     125 *  @return             EINVAL if the sent array differs in size.
     126 *  @return             EINVAL if there is inconsistency in sent measured
    128127 *                      strings' lengths (should not occur).
    129  *  @returns            ENOMEM if there is not enough memory left.
    130  *  @returns            Other error codes as defined for the
     128 *  @return             ENOMEM if there is not enough memory left.
     129 *  @return             Other error codes as defined for the
    131130 *                      async_data_write_finalize() function.
    132131 */
    133132int
    134 measured_strings_receive(measured_string_ref *strings, char **data,
     133measured_strings_receive(measured_string_t **strings, uint8_t **data,
    135134    size_t count)
    136135{
    137         ERROR_DECLARE;
    138 
    139136        size_t *lengths;
    140137        size_t index;
    141138        size_t length;
    142         char *next;
     139        uint8_t *next;
    143140        ipc_callid_t callid;
     141        int rc;
    144142
    145143        if ((!strings) || (!data) || (count <= 0))
    … …  
    155153                return EINVAL;
    156154        }
    157         if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
    158             length))) {
    159                 free(lengths);
    160                 return ERROR_CODE;
     155        rc = async_data_write_finalize(callid, lengths, length);
     156        if (rc != EOK) {
     157                free(lengths);
     158                return rc;
    161159        }
    162160
    … …  
    168166        (*data)[lengths[count] - 1] = '\0';
    169167
    170         *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
     168        *strings = (measured_string_t *) malloc(sizeof(measured_string_t) *
    171169            count);
    172170        if (!*strings) {
    … …  
    187185                                return EINVAL;
    188186                        }
    189                         if (ERROR_OCCURRED(async_data_write_finalize(callid,
    190                             next, lengths[index]))) {
     187                        rc = async_data_write_finalize(callid, next,
     188                            lengths[index]);
     189                        if (rc != EOK) {
    191190                                free(*data);
    192191                                free(*strings);
    193192                                free(lengths);
    194                                 return ERROR_CODE;
     193                                return rc;
    195194                        }
    196195                        (*strings)[index].value = next;
    … …  
    210209 * @param[in] strings   The measured strings array to be processed.
    211210 * @param[in] count     The measured strings array size.
    212  * @returns             The computed sizes array.
    213  * @returns             NULL if there is not enough memory left.
    214  */
    215 static size_t *prepare_lengths(const measured_string_ref strings, size_t count)
     211 * @return              The computed sizes array.
     212 * @return              NULL if there is not enough memory left.
     213 */
     214static size_t *prepare_lengths(const measured_string_t *strings, size_t count)
    216215{
    217216        size_t *lengths;
    … …  
    239238 * @param[in] strings   The measured strings array to be transferred.
    240239 * @param[in] count     The measured strings array size.
    241  * @returns             EOK on success.
    242  * @returns             EINVAL if the strings parameter is NULL.
    243  * @returns             EINVAL if the count parameter is zero (0).
    244  * @returns             EINVAL if the calling module does not accept the given
     240 * @return              EOK on success.
     241 * @return              EINVAL if the strings parameter is NULL.
     242 * @return              EINVAL if the count parameter is zero (0).
     243 * @return              EINVAL if the calling module does not accept the given
    245244 *                      array size.
    246  * @returns             EINVAL if there is inconsistency in sent measured
     245 * @return              EINVAL if there is inconsistency in sent measured
    247246 *                      strings' lengths (should not occur).
    248  * @returns             Other error codes as defined for the
     247 * @return              Other error codes as defined for the
    249248 *                      async_data_read_finalize() function.
    250249 */
    251 int measured_strings_reply(const measured_string_ref strings, size_t count)
    252 {
    253         ERROR_DECLARE;
    254 
     250int measured_strings_reply(const measured_string_t *strings, size_t count)
     251{
    255252        size_t *lengths;
    256253        size_t index;
    257254        size_t length;
    258255        ipc_callid_t callid;
     256        int rc;
    259257
    260258        if ((!strings) || (count <= 0))
    … …  
    270268                return EINVAL;
    271269        }
    272         if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
    273                 free(lengths);
    274                 return ERROR_CODE;
     270        rc = async_data_read_finalize(callid, lengths, length);
     271        if (rc != EOK) {
     272                free(lengths);
     273                return rc;
    275274        }
    276275        free(lengths);
    … …  
    282281                                return EINVAL;
    283282                        }
    284                         ERROR_PROPAGATE(async_data_read_finalize(callid,
    285                             strings[index].value, strings[index].length));
     283                        rc = async_data_read_finalize(callid,
     284                            strings[index].value, strings[index].length);
     285                        if (rc != EOK)
     286                                return rc;
    286287                }
    287288        }
    … …  
    301302 *                      actual character strings.
    302303 * @param[in] count     The size of the measured strings array.
    303  * @returns             EOK on success.
    304  * @returns             EINVAL if the strings or data parameter is NULL.
    305  * @returns             EINVAL if the phone or count parameter is not positive.
    306  * @returns             EINVAL if the sent array differs in size.
    307  * @returns             ENOMEM if there is not enough memory left.
    308  * @returns             Other error codes as defined for the
     304 * @return              EOK on success.
     305 * @return              EINVAL if the strings or data parameter is NULL.
     306 * @return              EINVAL if the phone or count parameter is not positive.
     307 * @return              EINVAL if the sent array differs in size.
     308 * @return              ENOMEM if there is not enough memory left.
     309 * @return              Other error codes as defined for the
    309310 *                      async_data_read_start() function.
    310311 */
    311312int
    312 measured_strings_return(int phone, measured_string_ref *strings, char **data,
     313measured_strings_return(int phone, measured_string_t **strings, uint8_t **data,
    313314    size_t count)
    314315{
    315         ERROR_DECLARE;
    316 
    317316        size_t *lengths;
    318317        size_t index;
    319         char *next;
     318        uint8_t *next;
     319        int rc;
    320320
    321321        if ((phone < 0) || (!strings) || (!data) || (count <= 0))
    … …  
    326326                return ENOMEM;
    327327
    328         if (ERROR_OCCURRED(async_data_read_start(phone, lengths,
    329             sizeof(size_t) * (count + 1)))) {
    330                 free(lengths);
    331                 return ERROR_CODE;
     328        rc = async_data_read_start(phone, lengths,
     329            sizeof(size_t) * (count + 1));
     330        if (rc != EOK) {
     331                free(lengths);
     332                return rc;
    332333        }
    333334
    … …  
    338339        }
    339340
    340         *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
     341        *strings = (measured_string_t *) malloc(sizeof(measured_string_t) *
    341342            count);
    342343        if (!*strings) {
    … …  
    350351                (*strings)[index].length = lengths[index];
    351352                if (lengths[index] > 0) {
    352                         if (ERROR_OCCURRED(async_data_read_start(phone, next,
    353                             lengths[index]))) {
     353                        rc = async_data_read_start(phone, next, lengths[index]);
     354                        if (rc != EOK) {
    354355                                free(lengths);
    355356                                free(data);
    356357                                free(strings);
    357                                 return ERROR_CODE;
     358                                return rc;
    358359                        }
    359360                        (*strings)[index].value = next;
    … …  
    377378 * @param[in] strings   The measured strings array to be transferred.
    378379 * @param[in] count     The measured strings array size.
    379  * @returns             EOK on success.
    380  * @returns             EINVAL if the strings parameter is NULL.
    381  * @returns             EINVAL if the phone or count parameter is not positive.
    382  * @returns             Other error codes as defined for the
     380 * @return              EOK on success.
     381 * @return              EINVAL if the strings parameter is NULL.
     382 * @return              EINVAL if the phone or count parameter is not positive.
     383 * @return              Other error codes as defined for the
    383384 *                      async_data_write_start() function.
    384385 */
    385386int
    386 measured_strings_send(int phone, const measured_string_ref strings,
     387measured_strings_send(int phone, const measured_string_t *strings,
    387388    size_t count)
    388389{
    389         ERROR_DECLARE;
    390 
    391390        size_t *lengths;
    392391        size_t index;
     392        int rc;
    393393
    394394        if ((phone < 0) || (!strings) || (count <= 0))
    … …  
    399399                return ENOMEM;
    400400
    401         if (ERROR_OCCURRED(async_data_write_start(phone, lengths,
    402             sizeof(size_t) * (count + 1)))) {
    403                 free(lengths);
    404                 return ERROR_CODE;
     401        rc = async_data_write_start(phone, lengths,
     402            sizeof(size_t) * (count + 1));
     403        if (rc != EOK) {
     404                free(lengths);
     405                return rc;
    405406        }
    406407
    … …  
    409410        for (index = 0; index < count; index++) {
    410411                if (strings[index].length > 0) {
    411                         ERROR_PROPAGATE(async_data_write_start(phone,
    412                             strings[index].value, strings[index].length));
     412                        rc = async_data_write_start(phone, strings[index].value,
     413                            strings[index].length);
     414                        if (rc != EOK)
     415                                return rc;
    413416                }
    414417        }
Note: See TracChangeset for help on using the changeset viewer.