Changeset f6b5ed2 in rtems


Ignore:
Timestamp:
May 26, 2010, 4:15:02 AM (9 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, master
Children:
fa1019f1
Parents:
862b24a
Message:

2010-05-26 Ralf Corsépius <ralf.corsepius@…>

  • librpc/src/rpc/clnt_tcp.c: Partial merger from freebsd (Fix strict-aliasing).
Location:
cpukit
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r862b24a rf6b5ed2  
     12010-05-26      Ralf Corsépius <ralf.corsepius@rtems.org>
     2
     3        * librpc/src/rpc/clnt_tcp.c: Partial merger from freebsd
     4        (Fix strict-aliasing).
     5
    162010-05-26      Ralf Corsépius <ralf.corsepius@rtems.org>
    27
  • cpukit/librpc/src/rpc/clnt_tcp.c

    r862b24a rf6b5ed2  
    9191struct ct_data {
    9292        int             ct_sock;
    93         bool_t          ct_closeit;
    94         struct timeval  ct_wait;
     93        bool_t          ct_closeit;     /* close it on destroy */
     94        struct timeval  ct_wait;        /* wait interval in milliseconds */
    9595        bool_t          ct_waitset;       /* wait set by clnt_control? */
    9696        struct sockaddr_in ct_addr;
    9797        struct rpc_err  ct_error;
    98         char            ct_mcall[MCALL_MSG_SIZE];       /* marshalled callmsg */
     98        union {
     99                char    ct_mcallc[MCALL_MSG_SIZE];      /* marshalled callmsg */
     100                u_int32_t ct_mcalli;
     101        } ct_u;
    99102        u_int           ct_mpos;                        /* pos after marshal */
    100         XDR             ct_xdrs;
     103        XDR             ct_xdrs;        /* XDR stream */
    101104};
    102105
     
    125128{
    126129        CLIENT *h;
    127         register struct ct_data *ct = NULL;
     130        struct ct_data *ct = NULL;      /* client handle */
    128131        struct timeval now;
    129132        struct rpc_msg call_msg;
     
    140143                goto fooy;
    141144        }
    142         ct = (struct ct_data *)mem_alloc(sizeof(*ct));
     145        ct = (struct ct_data *)mem_alloc(sizeof (*ct));
    143146        if (ct == NULL) {
    144147                (void)fprintf(stderr, "clnttcp_create: out of memory\n");
     
    202205         * pre-serialize the static part of the call msg and stash it away
    203206         */
    204         xdrmem_create(&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
     207        xdrmem_create(&(ct->ct_xdrs), ct->ct_u.ct_mcallc, MCALL_MSG_SIZE,
    205208            XDR_ENCODE);
    206209        if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
     
    245248        struct timeval timeout)
    246249{
    247         register struct ct_data *ct = (struct ct_data *) h->cl_private;
    248         register XDR *xdrs = &(ct->ct_xdrs);
     250        struct ct_data *ct = (struct ct_data *) h->cl_private;
     251        XDR *xdrs = &(ct->ct_xdrs);
    249252        struct rpc_msg reply_msg;
    250         u_long x_id;
    251         u_int32_t *msg_x_id = (u_int32_t *)(ct->ct_mcall);      /* yuk */
    252         register bool_t shipnow;
     253        u_int32_t x_id;
     254        u_int32_t *msg_x_id = &ct->ct_u.ct_mcalli;      /* yuk */
     255        bool_t shipnow;
    253256        int refreshes = 2;
    254257
     
    265268        ct->ct_error.re_status = RPC_SUCCESS;
    266269        x_id = ntohl(--(*msg_x_id));
    267         if ((! XDR_PUTBYTES(xdrs, ct->ct_mcall, ct->ct_mpos)) ||
     270        if ((! XDR_PUTBYTES(xdrs, ct->ct_u.ct_mcallc, ct->ct_mpos)) ||
    268271            (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
    269272            (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
     
    274277                return (ct->ct_error.re_status);
    275278        }
    276         if (! xdrrec_endofrecord(xdrs, shipnow))
     279        if (! xdrrec_endofrecord(xdrs, shipnow)) {
    277280                return (ct->ct_error.re_status = RPC_CANTSEND);
    278         if (! shipnow)
     281        }
     282        if (! shipnow) {
    279283                return (RPC_SUCCESS);
     284        }
    280285        /*
    281286         * Hack to provide rpc-based message passing
     
    293298                reply_msg.acpted_rply.ar_verf = _null_auth;
    294299                reply_msg.acpted_rply.ar_results.where = NULL;
    295                 reply_msg.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
     300                reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
    296301                if (! xdrrec_skiprecord(xdrs))
    297302                        return (ct->ct_error.re_status);
     
    337342        struct rpc_err *errp)
    338343{
    339         register struct ct_data *ct =
    340             (struct ct_data *) h->cl_private;
    341 
     344        struct ct_data *ct;
     345
     346        ct = (struct ct_data *) h->cl_private;
    342347        *errp = ct->ct_error;
    343348}
     
    349354        caddr_t res_ptr)
    350355{
    351         register struct ct_data *ct = (struct ct_data *)cl->cl_private;
    352         register XDR *xdrs = &(ct->ct_xdrs);
    353 
     356        struct ct_data *ct;
     357        XDR *xdrs;
     358
     359        ct = (struct ct_data *)cl->cl_private;
     360        xdrs = &(ct->ct_xdrs);
     361       
    354362        xdrs->x_op = XDR_FREE;
    355363        return ((*xdr_res)(xdrs, res_ptr));
     
    368376        char *info)
    369377{
    370         register struct ct_data *ct = (struct ct_data *)cl->cl_private;
    371         register struct timeval *tv;
     378        struct ct_data *ct;
     379        struct timeval *tv;
    372380        socklen_t len;
     381       
     382        ct = (struct ct_data *)cl->cl_private;
    373383
    374384        switch (request) {
     
    405415                /*
    406416                 * use the knowledge that xid is the
    407                  * first element in the call structure *.
     417                 * first element in the call structure
    408418                 * This will get the xid of the PREVIOUS call
    409419                 */
    410420                if (info == NULL)
    411421                        return(FALSE);
    412                 *(u_long *)info = ntohl(*(u_long *)ct->ct_mcall);
     422                *(u_int32_t *)info =
     423                        ntohl(*(u_int32_t *)&ct->ct_u.ct_mcalli);
    413424                break;
    414425        case CLSET_XID:
     
    416427                if (info == NULL)
    417428                        return(FALSE);
    418                 *(u_long *)ct->ct_mcall =  htonl(*(u_long *)info - 1);
     429                *(u_int32_t *)&ct->ct_u.ct_mcalli =
     430                        htonl(*((u_int32_t *)info) + 1);
    419431                /* decrement by 1 as clnttcp_call() increments once */
    420432        case CLGET_VERS:
     
    427439                if (info == NULL)
    428440                        return(FALSE);
    429                 *(u_long *)info = ntohl(*(u_long *)(ct->ct_mcall +
     441                *(u_int32_t *)info =
     442                        ntohl(*(u_int32_t *)(ct->ct_u.ct_mcallc +
    430443                                                4 * BYTES_PER_XDR_UNIT));
    431444                break;
     
    433446                if (info == NULL)
    434447                        return(FALSE);
    435                 *(u_long *)(ct->ct_mcall + 4 * BYTES_PER_XDR_UNIT)
    436                                 = htonl(*(u_long *)info);
    437                 break;
     448                *(u_int32_t *)(ct->ct_u.ct_mcallc +
     449                        4 * BYTES_PER_XDR_UNIT) =
     450                        htonl(*(u_int32_t *)info);
     451                break;
     452
    438453        case CLGET_PROG:
    439454                /*
    440455                 * This RELIES on the information that, in the call body,
    441                  * the program number field is the field from the
     456                 * the program number field is the fourth field from the
    442457                 * begining of the RPC header. MUST be changed if the
    443458                 * call_struct is changed
     
    445460                if (info == NULL)
    446461                        return(FALSE);
    447                 *(u_long *)info = ntohl(*(u_long *)(ct->ct_mcall +
     462                *(u_int32_t *)info = ntohl(*(u_int32_t *)(ct->ct_u.ct_mcallc +
    448463                                                3 * BYTES_PER_XDR_UNIT));
    449464                break;
     465
    450466        case CLSET_PROG:
    451467                if (info == NULL)
    452468                        return(FALSE);
    453                 *(u_long *)(ct->ct_mcall + 3 * BYTES_PER_XDR_UNIT)
    454                                 = htonl(*(u_long *)info);
    455                 break;
     469                *(u_int32_t *)(ct->ct_u.ct_mcallc + 3 * BYTES_PER_XDR_UNIT)
     470                                = htonl(*(u_int32_t *)info);
     471                break;
     472
    456473        case CLGET_LOCAL_ADDR:
    457474                len = sizeof(struct sockaddr);
     
    459476                        return(FALSE);
    460477                break;
     478
    461479        case CLGET_RETRY_TIMEOUT:
    462480        case CLSET_RETRY_TIMEOUT:
     
    476494        CLIENT *h)
    477495{
    478         register struct ct_data *ct =
     496        struct ct_data *ct =
    479497            (struct ct_data *) h->cl_private;
    480498
     
    483501        }
    484502        XDR_DESTROY(&(ct->ct_xdrs));
    485         mem_free((caddr_t)ct, sizeof(struct ct_data));
    486         mem_free((caddr_t)h, sizeof(CLIENT));
     503        mem_free(ct, sizeof(struct ct_data));
     504        mem_free(h, sizeof(CLIENT));
    487505}
    488506
     
    575593{
    576594        struct ct_data *ct = (struct ct_data *) _ct;
    577         register int i, cnt;
     595        int i, cnt;
    578596
    579597        for (cnt = len; cnt > 0; cnt -= i, buf += i) {
Note: See TracChangeset for help on using the changeset viewer.