Changes in / [6e8ed225:acdb5bac] in mainline


Ignore:
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/arch/pm.h

    r6e8ed225 racdb5bac  
    5757#ifdef CONFIG_FB
    5858
     59#define VESA_INIT_DES      8
    5960#define VESA_INIT_SEGMENT  0x8000
    60 #define VESA_INIT_CODE_DES      8
    61 #define VESA_INIT_DATA_DES      9
    6261
    6362#undef GDT_ITEMS
    64 #define GDT_ITEMS  10
     63#define GDT_ITEMS  9
    6564
    6665#endif /* CONFIG_FB */

  • kernel/arch/amd64/src/pm.c

    r6e8ed225 racdb5bac  
    112112        /* VESA Init descriptor */
    113113#ifdef CONFIG_FB
    114         { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | AR_READABLE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 },
    115         { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
     114        {
     115                0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL,
     116                    0xf, 0, 0, 0, 0, 0
     117        }
    116118#endif
    117119};

  • kernel/arch/ia32/include/arch/pm.h

    r6e8ed225 racdb5bac  
    5050
    5151#define VESA_INIT_SEGMENT  0x8000
    52 #define VESA_INIT_CODE_DES      7
    53 #define VESA_INIT_DATA_DES      8
     52#define VESA_INIT_DES      7
    5453#define KTEXT32_DES        KTEXT_DES
    5554
    5655#undef GDT_ITEMS
    57 #define GDT_ITEMS  9
     56#define GDT_ITEMS  8
    5857
    5958#endif /* CONFIG_FB */
    … …  
    6867#define AR_CODE       (3 << 3)
    6968#define AR_WRITABLE   (1 << 1)
    70 #define AR_READABLE   (1 << 1)
    7169#define AR_INTERRUPT  (0xe)
    7270#define AR_TRAP       (0xf)

  • kernel/arch/ia32/src/boot/vesa_real.inc

    r6e8ed225 racdb5bac  
    3131vesa_init:
    3232        lidtl vesa_idtr
    33        
    34         mov $GDT_SELECTOR(VESA_INIT_DATA_DES), %bx
    35        
    36         mov %bx, %es
    37         mov %bx, %fs
    38         mov %bx, %gs
    39         mov %bx, %ds
    40         mov %bx, %ss
    41        
    42         jmp $GDT_SELECTOR(VESA_INIT_CODE_DES), $vesa_init_real - vesa_init
     33        jmp $GDT_SELECTOR(VESA_INIT_DES), $vesa_init_real - vesa_init
    4334
    4435vesa_idtr:
    … …  
    4839.code16
    4940vesa_init_real:
     41       
    5042        mov %cr0, %eax
    5143        and $~1, %eax
    … …  
    5345       
    5446        jmp $VESA_INIT_SEGMENT, $vesa_init_real2 - vesa_init
    55 
     47       
    5648vesa_init_real2:
    5749        mov $VESA_INIT_SEGMENT, %bx

  • kernel/arch/ia32/src/pm.c

    r6e8ed225 racdb5bac  
    7575        /* VESA Init descriptor */
    7676#ifdef CONFIG_FB
    77         { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | AR_READABLE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 },
    78         { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
     77        { 0xffff, 0, VESA_INIT_SEGMENT >> 12, AR_PRESENT | AR_CODE | DPL_KERNEL, 0xf, 0, 0, 0, 0, 0 }
    7978#endif
    8079};

  • uspace/app/dnsres/dnsres.c

    r6e8ed225 racdb5bac  
    5050        int rc;
    5151        dnsr_hostinfo_t *hinfo;
    52         char *hname;
    5352        char *saddr;
    5453
    … …  
    5857        }
    5958
    60         hname = argv[1];
    61 
    62         rc = dnsr_name2host(hname, &hinfo);
     59        rc = dnsr_name2host(argv[1], &hinfo);
    6360        if (rc != EOK) {
    6461                printf(NAME ": Error resolving '%s'.\n", argv[1]);
    … …  
    7370        }
    7471
    75         printf("Host name: %s\n", hname);
    76         if (str_cmp(hname, hinfo->cname) != 0)
    77                 printf("Canonical name: %s\n", hinfo->cname);
    78         printf("Address: %s\n", saddr);
    79 
     72        printf("Host name: %s address: %s\n", hinfo->name, saddr);
    8073        dnsr_hostinfo_destroy(hinfo);
    8174        free(saddr);

  • uspace/app/ping/ping.c

    r6e8ed225 racdb5bac  
    234234
    235235        if (hinfo != NULL) {
    236                 rc = asprintf(&sdest, "%s (%s)", hinfo->cname, adest);
     236                rc = asprintf(&sdest, "%s (%s)", hinfo->name, adest);
    237237                if (rc < 0) {
    238238                        printf(NAME ": Out of memory.\n");

  • uspace/lib/c/generic/dnsr.c

    r6e8ed225 racdb5bac  
    7171{
    7272        async_exch_t *exch = dnsr_exchange_begin();
    73         char cname_buf[DNSR_NAME_MAX_SIZE + 1];
    74         ipc_call_t cnreply;
    75         size_t act_size;
    7673        dnsr_hostinfo_t *info;
    7774
    … …  
    7976        aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
    8077        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    81         aid_t cnreq = async_data_read(exch, cname_buf, DNSR_NAME_MAX_SIZE,
    82             &cnreply);
    8378
    8479        dnsr_exchange_end(exch);
    … …  
    8681        if (retval != EOK) {
    8782                async_forget(req);
    88                 async_forget(cnreq);
    8983                return retval;
    9084        }
    9185
    9286        async_wait_for(req, &retval);
    93         if (retval != EOK) {
    94                 async_forget(cnreq);
    95                 return EIO;
    96         }
    97 
    98         async_wait_for(cnreq, &retval);
    9987        if (retval != EOK)
    10088                return EIO;
    … …  
    10492                return ENOMEM;
    10593
    106         act_size = IPC_GET_ARG2(cnreply);
    107         assert(act_size <= DNSR_NAME_MAX_SIZE);
    108         cname_buf[act_size] = '\0';
    109 
    110         info->cname = str_dup(cname_buf);
     94        info->name = str_dup(name);
    11195        info->addr.ipv4 = IPC_GET_ARG1(answer);
    11296
    … …  
    120104                return;
    121105
    122         free(info->cname);
     106        free(info->name);
    123107        free(info);
    124108}

  • uspace/lib/c/include/inet/dnsr.h

    r6e8ed225 racdb5bac  
    3838#include <inet/inet.h>
    3939
    40 enum {
    41         DNSR_NAME_MAX_SIZE = 255
    42 };
    43 
    4440typedef struct {
    45         /** Host canonical name */
    46         char *cname;
     41        /** Host name */
     42        char *name;
    4743        /** Host address */
    4844        inet_addr_t addr;

  • uspace/srv/net/dnsrsrv/dns_msg.c

    r6e8ed225 racdb5bac  
    5050static uint16_t dns_uint16_t_decode(uint8_t *, size_t);
    5151
    52 /** Extend dynamically allocated string with suffix.
    53  *
    54  * @a *dstr points to a dynamically alocated buffer containing a string.
    55  * Reallocate this buffer so that concatenation of @a *dstr and @a suff can
    56  * fit in and append @a suff.
    57  */
    5852static int dns_dstr_ext(char **dstr, const char *suff)
    5953{
    … …  
    8377}
    8478
    85 /** Encode DNS name.
    86  *
    87  * Encode DNS name or measure the size of encoded name (with @a buf NULL,
    88  * and @a buf_size 0).
    89  *
    90  * @param name          String to encode
    91  * @param buf           Buffer or NULL
    92  * @param buf_size      Buffer size or 0 if @a buf is NULL
    93  * @param act_size      Place to store actual encoded size
    94  */
    9579static int dns_name_encode(char *name, uint8_t *buf, size_t buf_size,
    9680    size_t *act_size)
    … …  
    151135}
    152136
    153 /** Decode DNS name.
    154  *
    155  * @param pdu   PDU from which we are decoding
    156  * @param boff  Starting offset within PDU
    157  * @param rname Place to return dynamically allocated string
    158  * @param eoff  Place to store end offset (offset after last decoded byte)
    159  */
    160 int dns_name_decode(dns_pdu_t *pdu, size_t boff, char **rname,
     137static int dns_name_decode(uint8_t *buf, size_t size, size_t boff, char **rname,
    161138    size_t *eoff)
    162139{
    … …  
    174151        name = NULL;
    175152
    176         if (boff > pdu->size)
     153        if (boff > size)
    177154                return EINVAL;
    178155
    179         bp = pdu->data + boff;
    180         bsize = min(pdu->size - boff, DNS_NAME_MAX_SIZE);
     156        bp = buf + boff;
     157        bsize = min(size - boff, DNS_NAME_MAX_SIZE);
    181158        first = true;
    182159        *eoff = 0;
    … …  
    215192                        --bsize;
    216193
    217                         if (ptr >= (size_t)(bp - pdu->data)) {
     194                        if (ptr >= (size_t)(bp - buf)) {
    218195                                log_msg(LOG_DEFAULT, LVL_DEBUG,
    219196                                    "Pointer- forward ref %zu, pos=%zu",
    220                                     ptr, (size_t)(bp - pdu->data));
     197                                    ptr, (size_t)(bp - buf));
    221198                                /* Forward reference */
    222199                                rc = EINVAL;
    … …  
    228205                         * XXX Is assumption correct?
    229206                         */
    230                         eptr = bp - pdu->data;
     207                        eptr = bp - buf;
    231208                        /*
    232209                         * This is where encoded name ends in terms where
    … …  
    235212                        *eoff = eptr;
    236213
    237                         bp = pdu->data + ptr;
     214                        bp = buf + ptr;
    238215                        bsize = eptr - ptr;
    239216                        continue;
    … …  
    268245        *rname = name;
    269246        if (*eoff == 0)
    270                 *eoff = bp - pdu->data;
     247                *eoff = bp - buf;
    271248        return EOK;
    272249error:
    … …  
    307284}
    308285
    309 /** Encode DNS question.
    310  *
    311  * Encode DNS question or measure the size of encoded question (with @a buf NULL,
    312  * and @a buf_size 0).
    313  *
    314  * @param question      Question to encode
    315  * @param buf           Buffer or NULL
    316  * @param buf_size      Buffer size or 0 if @a buf is NULL
    317  * @param act_size      Place to store actual encoded size
    318  */
    319286static int dns_question_encode(dns_question_t *question, uint8_t *buf,
    320287    size_t buf_size, size_t *act_size)
    … …  
    343310}
    344311
    345 /** Decode DNS question.
    346  *
    347  * @param pdu           PDU from which we are decoding
    348  * @param boff          Starting offset within PDU
    349  * @param rquestion     Place to return dynamically allocated question
    350  * @param eoff          Place to store end offset (offset after last decoded byte)
    351  */
    352 static int dns_question_decode(dns_pdu_t *pdu, size_t boff,
     312static int dns_question_decode(uint8_t *buf, size_t buf_size, size_t boff,
    353313    dns_question_t **rquestion, size_t *eoff)
    354314{
    … …  
    361321                return ENOMEM;
    362322
    363         rc = dns_name_decode(pdu, boff, &question->qname, &name_eoff);
     323        rc = dns_name_decode(buf, buf_size, boff, &question->qname, &name_eoff);
    364324        if (rc != EOK) {
    365325                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error decoding name");
    … …  
    368328        }
    369329
    370         if (name_eoff + 2 * sizeof(uint16_t) > pdu->size) {
     330        if (name_eoff + 2 * sizeof(uint16_t) > buf_size) {
    371331                free(question);
    372332                return EINVAL;
    373333        }
    374334
    375         question->qtype = dns_uint16_t_decode(pdu->data + name_eoff,
    376             pdu->size - name_eoff);
    377         question->qclass = dns_uint16_t_decode(pdu->data + sizeof(uint16_t)
    378             + name_eoff, pdu->size - sizeof(uint16_t) - name_eoff);
     335        question->qtype = dns_uint16_t_decode(buf + name_eoff, buf_size - name_eoff);
     336        question->qclass = dns_uint16_t_decode(buf + sizeof(uint16_t) + name_eoff,
     337            buf_size - sizeof(uint16_t) - name_eoff);
    379338        *eoff = name_eoff + 2 * sizeof(uint16_t);
    380339
    … …  
    383342}
    384343
    385 /** Decode DNS resource record.
    386  *
    387  * @param pdu           PDU from which we are decoding
    388  * @param boff          Starting offset within PDU
    389  * @param retrr         Place to return dynamically allocated resource record
    390  * @param eoff          Place to store end offset (offset after last decoded byte)
    391  */
    392 static int dns_rr_decode(dns_pdu_t *pdu, size_t boff, dns_rr_t **retrr,
    393     size_t *eoff)
     344static int dns_rr_decode(uint8_t *buf, size_t buf_size, size_t boff,
     345    dns_rr_t **retrr, size_t *eoff)
    394346{
    395347        dns_rr_t *rr;
    … …  
    404356                return ENOMEM;
    405357
    406         rc = dns_name_decode(pdu, boff, &rr->name, &name_eoff);
     358        rc = dns_name_decode(buf, buf_size, boff, &rr->name, &name_eoff);
    407359        if (rc != EOK) {
    408360                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error decoding name");
    … …  
    411363        }
    412364
    413         if (name_eoff + 2 * sizeof(uint16_t) > pdu->size) {
     365        if (name_eoff + 2 * sizeof(uint16_t) > buf_size) {
    414366                free(rr->name);
    415367                free(rr);
    … …  
    417369        }
    418370
    419         bp = pdu->data + name_eoff;
    420         bsz = pdu->size - name_eoff;
     371        bp = buf + name_eoff;
     372        bsz = buf_size - name_eoff;
    421373
    422374        if (bsz < 3 * sizeof(uint16_t) + sizeof(uint32_t)) {
    … …  
    453405
    454406        memcpy(rr->rdata, bp, rdlength);
    455         rr->roff = bp - pdu->data;
    456407        bp += rdlength;
    457408        bsz -= rdlength;
    458409
    459         *eoff = bp - pdu->data;
     410        *eoff = bp - buf;
    460411        *retrr = rr;
    461412        return EOK;
    462413}
    463414
    464 /** Encode DNS message.
    465  *
    466  * @param msg   Message
    467  * @param rdata Place to store encoded data pointer
    468  * @param rsize Place to store encoded data size
    469  *
    470  * @return      EOK on success, EINVAL if message contains invalid data,
    471  *              ENOMEM if out of memory
    472  */
    473415int dns_message_encode(dns_message_t *msg, void **rdata, size_t *rsize)
    474416{
    … …  
    532474}
    533475
    534 /** Decode DNS message.
    535  *
    536  * @param data  Encoded PDU data
    537  * @param size  Encoded PDU size
    538  * @param rmsg  Place to store pointer to decoded message
    539  *
    540  * @return      EOK on success, EINVAL if message contains invalid data,
    541  *              ENOMEM if out of memory
    542  */
    543476int dns_message_decode(void *data, size_t size, dns_message_t **rmsg)
    544477{
    … …  
    558491                return ENOMEM;
    559492
    560         if (size < sizeof(dns_header_t)) {
    561                 rc = EINVAL;
    562                 goto error;
    563         }
    564 
    565         /* Store a copy of raw message data for string decompression */
    566 
    567         msg->pdu.data = malloc(size);
    568         if (msg->pdu.data == NULL) {
    569                 rc = ENOMEM;
    570                 goto error;
    571         }
    572 
    573         memcpy(msg->pdu.data, data, size);
    574         msg->pdu.size = size;
    575         log_msg(LOG_DEFAULT, LVL_NOTE, "dns_message_decode: pdu->data = %p, "
    576             "pdu->size=%zu", msg->pdu.data, msg->pdu.size);
     493        if (size < sizeof(dns_header_t))
     494                return EINVAL;
    577495
    578496        hdr = data;
    … …  
    594512
    595513        for (i = 0; i < qd_count; i++) {
    596                 rc = dns_question_decode(&msg->pdu, doff, &question, &field_eoff);
     514                rc = dns_question_decode(data, size, doff, &question, &field_eoff);
    597515                if (rc != EOK) {
    598516                        log_msg(LOG_DEFAULT, LVL_DEBUG, "error decoding question");
    … …  
    607525
    608526        for (i = 0; i < an_count; i++) {
    609                 rc = dns_rr_decode(&msg->pdu, doff, &rr, &field_eoff);
     527                rc = dns_rr_decode(data, size, doff, &rr, &field_eoff);
    610528                if (rc != EOK) {
    611529                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Error decoding answer");
    … …  
    624542}
    625543
    626 /** Destroy question. */
    627544static void dns_question_destroy(dns_question_t *question)
    628545{
    … …  
    631548}
    632549
    633 /** Destroy resource record. */
    634550static void dns_rr_destroy(dns_rr_t *rr)
    635551{
    … …  
    639555}
    640556
    641 /** Create new empty message. */
    642557dns_message_t *dns_message_new(void)
    643558{
    … …  
    656571}
    657572
    658 /** Destroy message. */
    659573void dns_message_destroy(dns_message_t *msg)
    660574{
    … …  
    691605        }
    692606
    693         free(msg->pdu.data);
    694607        free(msg);
    695608}

  • uspace/srv/net/dnsrsrv/dns_msg.h

    r6e8ed225 racdb5bac  
    4747extern dns_message_t *dns_message_new(void);
    4848extern void dns_message_destroy(dns_message_t *);
    49 extern int dns_name_decode(dns_pdu_t *, size_t, char **, size_t *);
    5049extern uint32_t dns_uint32_t_decode(uint8_t *, size_t);
    5150

  • uspace/srv/net/dnsrsrv/dns_type.h

    r6e8ed225 racdb5bac  
    4343#include "dns_std.h"
    4444
    45 /** Encoded DNS PDU */
     45/** Unencoded DNS message */
    4646typedef struct {
    47         /** Encoded PDU data */
    48         uint8_t *data;
    49         /** Encoded PDU size */
    50         size_t size;
    51 } dns_pdu_t;
    52 
    53 /** DNS message */
    54 typedef struct {
    55         /* Encoded PDU */
    56         dns_pdu_t pdu;
    57 
    5847        /** Identifier */
    5948        uint16_t id;
    … …  
    10695        /** Number of bytes in @c *rdata */
    10796        size_t rdata_size;
    108         /** Offset in the raw message */
    109         size_t roff;
    11097} dns_rr_t;
    11198
    … …  
    113100typedef struct {
    114101        /** Host name */
    115         char *cname;
     102        char *name;
    116103        /** Host address */
    117104        inet_addr_t addr;

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r6e8ed225 racdb5bac  
    8989        char *name;
    9090        dns_host_info_t *hinfo;
    91         ipc_callid_t rcallid;
    92         size_t size;
    93         sysarg_t retval;
    94         size_t act_size;
    9591        int rc;
    9692
    … …  
    104100        }
    105101
    106         if (!async_data_read_receive(&rcallid, &size)) {
    107                 async_answer_0(rcallid, EREFUSED);
    108                 async_answer_0(callid, EREFUSED);
    109                 return;
    110         }
    111 
    112102        rc = dns_name2host(name, &hinfo);
    113103        if (rc != EOK) {
    114                 async_answer_0(rcallid, rc);
    115104                async_answer_0(callid, rc);
    116105                return;
    117106        }
    118107
    119         act_size = str_size(hinfo->cname);
    120         if (act_size > size) {
    121                 async_answer_0(rcallid, EOVERFLOW);
    122                 async_answer_0(callid, EOVERFLOW);
    123                 return;
    124         }
    125 
    126         retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
    127         async_answer_1(callid, retval, hinfo->addr.ipv4);
     108        async_answer_1(callid, EOK, hinfo->addr.ipv4);
    128109
    129110        dns_hostinfo_destroy(hinfo);

  • uspace/srv/net/dnsrsrv/query.c

    r6e8ed225 racdb5bac  
    5454        dns_question_t *question;
    5555        dns_host_info_t *info;
    56         char *sname, *cname;
    57         size_t eoff;
    5856        int rc;
    5957
    … …  
    8583        }
    8684
    87         /* Start with the caller-provided name */
    88         sname = str_dup(name);
    89 
    9085        list_foreach(amsg->answer, link) {
    9186                dns_rr_t *rr = list_get_instance(link, dns_rr_t, msg);
    … …  
    9489                        rr->name, rr->rtype, rr->rclass, rr->rdata_size);
    9590
    96                 if (rr->rtype == DTYPE_CNAME && rr->rclass == DC_IN &&
    97                     str_cmp(rr->name, sname) == 0) {
    98                         log_msg(LOG_DEFAULT, LVL_DEBUG, "decode cname (%p, %zu, %zu)",
    99                             amsg->pdu.data, amsg->pdu.size, rr->roff);
    100                         rc = dns_name_decode(&amsg->pdu, rr->roff, &cname, &eoff);
    101                         if (rc != EOK) {
    102                                 log_msg(LOG_DEFAULT, LVL_DEBUG,
    103                                     "error decoding cname");
    104                                 assert(rc == EINVAL || rc == ENOMEM);
    105                                 dns_message_destroy(msg);
    106                                 dns_message_destroy(amsg);
    107                                 return rc;
    108                         }
    109 
    110                         log_msg(LOG_DEFAULT, LVL_DEBUG, "name = '%s' "
    111                             "cname = '%s'", sname, cname);
    112 
    113                         free(sname);
    114                         /* Continue looking for the more canonical name */
    115                         sname = cname;
    116                 }
    117 
    11891                if (rr->rtype == DTYPE_A && rr->rclass == DC_IN &&
    119                         rr->rdata_size == sizeof(uint32_t) &&
    120                             str_cmp(rr->name, sname) == 0) {
     92                        rr->rdata_size == sizeof(uint32_t)) {
    12193
    12294                        info = calloc(1, sizeof(dns_host_info_t));
    12395                        if (info == NULL) {
    124                                 dns_message_destroy(msg);
    12596                                dns_message_destroy(amsg);
    12697                                return ENOMEM;
    12798                        }
    12899
    129                         info->cname = str_dup(rr->name);
     100                        info->name = str_dup(rr->name);
    130101                        info->addr.ipv4 = dns_uint32_t_decode(rr->rdata, rr->rdata_size);
    131                         log_msg(LOG_DEFAULT, LVL_DEBUG, "info->name = '%s' "
    132                             "info->addr = %x", info->cname, info->addr.ipv4);
     102                        log_msg(LOG_DEFAULT, LVL_DEBUG, "info->addr = %x",
     103                            info->addr.ipv4);
    133104
    134105                        dns_message_destroy(msg);
    … …  
    141112        dns_message_destroy(msg);
    142113        dns_message_destroy(amsg);
    143         log_msg(LOG_DEFAULT, LVL_DEBUG, "'%s' not resolved, fail", sname);
     114        log_msg(LOG_DEFAULT, LVL_DEBUG, "No A/IN found, fail");
    144115
    145116        return EIO;
    … …  
    148119void dns_hostinfo_destroy(dns_host_info_t *info)
    149120{
    150         free(info->cname);
     121        free(info->name);
    151122        free(info);
    152123}

  • uspace/srv/net/dnsrsrv/transport.c

    r6e8ed225 racdb5bac  
    5454#define REQ_TIMEOUT (5*1000*1000)
    5555
    56 /** Maximum number of retries */
    57 #define REQ_RETRY_MAX 3
    58 
    5956typedef struct {
    6057        link_t lreq;
    … …  
    187184        struct sockaddr_in addr;
    188185        trans_req_t *treq;
    189         int ntry;
    190186
    191187        req_data = NULL;
    … …  
    200196                goto error;
    201197
    202         ntry = 0;
    203 
    204         while (ntry < REQ_RETRY_MAX) {
    205                 rc = sendto(transport_fd, req_data, req_size, 0,
    206                     (struct sockaddr *)&addr, sizeof(addr));
    207                 if (rc != EOK)
    208                         goto error;
    209 
    210                 treq = treq_create(req);
    211                 if (treq == NULL) {
    212                         rc = ENOMEM;
     198        rc = sendto(transport_fd, req_data, req_size, 0,
     199            (struct sockaddr *)&addr, sizeof(addr));
     200        if (rc != EOK)
     201                goto error;
     202
     203        treq = treq_create(req);
     204        if (treq == NULL) {
     205                rc = ENOMEM;
     206                goto error;
     207        }
     208
     209        fibril_mutex_lock(&treq->done_lock);
     210        while (treq->done != true) {
     211                rc = fibril_condvar_wait_timeout(&treq->done_cv, &treq->done_lock,
     212                    REQ_TIMEOUT);
     213                if (rc == ETIMEOUT) {
     214                        fibril_mutex_unlock(&treq->done_lock);
     215                        rc = EIO;
    213216                        goto error;
    214217                }
    215 
    216 
    217                 fibril_mutex_lock(&treq->done_lock);
    218                 while (treq->done != true) {
    219                         rc = fibril_condvar_wait_timeout(&treq->done_cv, &treq->done_lock,
    220                             REQ_TIMEOUT);
    221                         if (rc == ETIMEOUT) {
    222                                 ++ntry;
    223                                 break;
    224                         }
    225                 }
    226 
    227                 fibril_mutex_unlock(&treq->done_lock);
    228 
    229                 if (rc != ETIMEOUT)
    230                         break;
    231         }
    232 
    233         if (ntry >= REQ_RETRY_MAX) {
    234                 rc = EIO;
    235                 goto error;
    236         }
     218        }
     219
     220        fibril_mutex_unlock(&treq->done_lock);
    237221
    238222        if (treq->status != EOK) {
Note: See TracChangeset for help on using the changeset viewer.