Xi: use REPLY_*() macros for preparing / sending replies

Use the new macros for preparing and sending replies to clients.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>

Xi/chgdctl.c

@@ -100,7 +100,6 @@ ProcXChangeDeviceControl(ClientPtr client)
 
     xChangeDeviceControlReply rep = {
         .RepType = X_ChangeDeviceControl,
-        .sequenceNumber = client->sequence,
         .status = Success,
     };
 
@@ -202,10 +201,7 @@ ProcXChangeDeviceControl(ClientPtr client)
         SendEventToAllWindows(dev, DevicePresenceNotifyMask,
                               (xEvent *) &dpn, 1);
 
-        if (client->swapped) {
+        REPLY_SEND();
-            swaps(&rep.sequenceNumber);
-        }
-        WriteToClient(client, sizeof(xChangeDeviceControlReply), &rep);
     }
 
     return ret;

Xi/getbmap.c

@@ -86,18 +86,11 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
         return BadMatch;
 
     xGetDeviceButtonMappingReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceButtonMapping,
-        .sequenceNumber = client->sequence,
         .nElts = b->numButtons,
         .length = bytes_to_int32(b->numButtons),
     };
 
-    if (client->swapped) {
+    REPLY_SEND_EXTRA(&b->map[1], rep.nElts);
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
-    WriteToClient(client, rep.nElts, &b->map[1]);
     return Success;
 }

Xi/getdctl.c

@@ -88,15 +88,10 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
         *iptr++ = a->min_resolution;
     for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
         *iptr++ = a->max_resolution;
-    if (client->swapped) {
+
-        swaps(&r->control);
+    CLIENT_STRUCT_CARD16_2(r, control, length);
-        swaps(&r->length);
+    CLIENT_STRUCT_CARD32_1(r, num_valuators);
-        swapl(&r->num_valuators);
+    REPLY_BUF_CARD32(buf, (3 * v->numAxes));
-        iptr = (int *) buf;
-        for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
-            swapl(iptr);
-        }
-    }
 }
 
 static void
@@ -109,10 +104,7 @@ CopySwapDeviceCore(ClientPtr client, DeviceIntPtr dev, char *buf)
     c->status = dev->coreEvents;
     c->iscore = (dev == inputInfo.keyboard || dev == inputInfo.pointer);
 
-    if (client->swapped) {
+    CLIENT_STRUCT_CARD16_2(c, control, length);
-        swaps(&c->control);
-        swaps(&c->length);
-    }
 }
 
 static void
@@ -124,10 +116,7 @@ CopySwapDeviceEnable(ClientPtr client, DeviceIntPtr dev, char *buf)
     e->length = sizeof(xDeviceEnableState);
     e->enable = dev->enabled;
 
-    if (client->swapped) {
+    CLIENT_STRUCT_CARD16_2(e, control, length);
-        swaps(&e->control);
-        swaps(&e->length);
-    }
 }
 
 /***********************************************************************
@@ -189,18 +178,10 @@ ProcXGetDeviceControl(ClientPtr client)
     }
 
     xGetDeviceControlReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceControl,
-        .sequenceNumber = client->sequence,
-        .length = bytes_to_int32(total_length),
     };
 
-    if (client->swapped) {
+    REPLY_SEND_EXTRA(buf, total_length);
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xGetDeviceControlReply), &rep);
-    WriteToClient(client, total_length, savbuf);
     free(savbuf);
     return Success;
 }

Xi/getfctl.c

@@ -86,13 +86,10 @@ CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
     k2->global_auto_repeat = k->ctrl.autoRepeat;
     for (i = 0; i < 32; i++)
         k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
-    if (client->swapped) {
+
-        swaps(&k2->length);
+    CLIENT_STRUCT_CARD16_3(k2, length, pitch, duration);
-        swaps(&k2->pitch);
+    CLIENT_STRUCT_CARD32_2(k2, led_mask, led_values);
-        swaps(&k2->duration);
+
-        swapl(&k2->led_mask);
-        swapl(&k2->led_values);
-    }
     *buf += sizeof(xKbdFeedbackState);
 }
 
@@ -114,12 +111,9 @@ CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
     p2->accelNum = p->ctrl.num;
     p2->accelDenom = p->ctrl.den;
     p2->threshold = p->ctrl.threshold;
-    if (client->swapped) {
+
-        swaps(&p2->length);
+    CLIENT_STRUCT_CARD16_4(p2, length, accelNum, accelDenom, threshold);
-        swaps(&p2->accelNum);
+
-        swaps(&p2->accelDenom);
-        swaps(&p2->threshold);
-    }
     *buf += sizeof(xPtrFeedbackState);
 }
 
@@ -141,12 +135,10 @@ CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
     i2->resolution = i->ctrl.resolution;
     i2->min_value = i->ctrl.min_value;
     i2->max_value = i->ctrl.max_value;
-    if (client->swapped) {
+
-        swaps(&i2->length);
+    CLIENT_STRUCT_CARD16_1(i2, length);
-        swapl(&i2->resolution);
+    CLIENT_STRUCT_CARD32_3(i2, resolution, min_value, max_value);
-        swapl(&i2->min_value);
+
-        swapl(&i2->max_value);
-    }
     *buf += sizeof(xIntegerFeedbackState);
 }
 
@@ -174,15 +166,10 @@ CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
     kptr = (KeySym *) (*buf);
     for (i = 0; i < s->ctrl.num_symbols_supported; i++)
         *kptr++ = *(s->ctrl.symbols_supported + i);
-    if (client->swapped) {
+
-        swaps(&s2->length);
+    CLIENT_STRUCT_CARD16_3(s2, length, max_symbols, num_syms_supported);
-        swaps(&s2->max_symbols);
+    REPLY_BUF_CARD32((CARD32*)buf, s->ctrl.num_symbols_supported);
-        swaps(&s2->num_syms_supported);
+
-        kptr = (KeySym *) (*buf);
-        for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
-            swapl(kptr);
-        }
-    }
     *buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
 }
 
@@ -203,11 +190,10 @@ CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
     l2->id = l->ctrl.id;
     l2->led_values = l->ctrl.led_values;
     l2->led_mask = l->ctrl.led_mask;
-    if (client->swapped) {
+
-        swaps(&l2->length);
+    CLIENT_STRUCT_CARD16_1(l2, length);
-        swapl(&l2->led_values);
+    CLIENT_STRUCT_CARD32_2(l2, led_values, led_mask);
-        swapl(&l2->led_mask);
+
-    }
     *buf += sizeof(xLedFeedbackState);
 }
 
@@ -229,11 +215,9 @@ CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
     b2->percent = b->ctrl.percent;
     b2->pitch = b->ctrl.pitch;
     b2->duration = b->ctrl.duration;
-    if (client->swapped) {
+
-        swaps(&b2->length);
+    CLIENT_STRUCT_CARD16_3(b2, length, pitch, duration);
-        swaps(&b2->pitch);
+
-        swaps(&b2->duration);
-    }
     *buf += sizeof(xBellFeedbackState);
 }
 
@@ -262,9 +246,7 @@ ProcXGetFeedbackControl(ClientPtr client)
         return rc;
 
     xGetFeedbackControlReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetFeedbackControl,
-        .sequenceNumber = client->sequence,
     };
 
     for (k = dev->kbdfeed; k; k = k->next) {
@@ -314,14 +296,7 @@ ProcXGetFeedbackControl(ClientPtr client)
     for (b = dev->bell; b; b = b->next)
         CopySwapBellFeedback(client, b, &buf);
 
-    rep.length = bytes_to_int32(total_length);
+    REPLY_FIELD_CARD16(num_feedbacks);
-
+    REPLY_SEND_EXTRA(savbuf, total_length);
-    if (client->swapped) {
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-        swaps(&rep.num_feedbacks);
-    }
-    WriteToClient(client, sizeof(xGetFeedbackControlReply), &rep);
-    WriteToClient(client, total_length, savbuf);
     return Success;
 }

Xi/getfocus.c

@@ -87,9 +87,7 @@ ProcXGetDeviceFocus(ClientPtr client)
     focus = dev->focus;
 
     xGetDeviceFocusReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceFocus,
-        .sequenceNumber = client->sequence,
         .time = focus->time.milliseconds,
         .revertTo = focus->revert,
     };
@@ -103,15 +101,8 @@ ProcXGetDeviceFocus(ClientPtr client)
     else
         rep.focus = focus->win->drawable.id;
 
-    rep.time = focus->time.milliseconds;
+    REPLY_FIELD_CARD32(focus);
-    rep.revertTo = focus->revert;
+    REPLY_FIELD_CARD32(time);
-
+    REPLY_SEND();
-    if (client->swapped) {
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-        swapl(&rep.focus);
-        swapl(&rep.time);
-    }
-    WriteToClient(client, sizeof(xGetDeviceFocusReply), &rep);
     return Success;
 }

Xi/getkmap.c

@@ -104,18 +104,12 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
         return BadAlloc;
 
     xGetDeviceKeyMappingReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceKeyMapping,
-        .sequenceNumber = client->sequence,
         .keySymsPerKeyCode = syms->mapWidth,
         .length = (syms->mapWidth * stuff->count) /* KeySyms are 4 bytes */
     };
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep);
 
     client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write;
     WriteSwappedDataToClient(client,

Xi/getmmap.c

@@ -86,21 +86,12 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
         return ret;
 
     xGetDeviceModifierMappingReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceModifierMapping,
-        .sequenceNumber = client->sequence,
         .numKeyPerModifier = max_keys_per_mod,
-        /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
-        .length = max_keys_per_mod << 1
     };
 
-    if (client->swapped) {
+    /* 8 modifiers per key, each CARD8 */
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND_EXTRA(modkeymap, max_keys_per_mod * 8);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xGetDeviceModifierMappingReply), &rep);
-    WriteToClient(client, max_keys_per_mod * 8, modkeymap);
-
     free(modkeymap);
 
     return Success;

Xi/getprop.c

@@ -86,9 +86,7 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
     REQUEST_FIELD_CARD32(window);
 
     xGetDeviceDontPropagateListReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceDontPropagateList,
-        .sequenceNumber = client->sequence,
     };
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -110,12 +108,8 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
         }
     }
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(count);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND();
-        swapl(&rep.length);
-        swaps(&rep.count);
-    }
-    WriteToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep);
 
     if (count) {
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

Xi/getselev.c

@@ -87,9 +87,7 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
     REQUEST_FIELD_CARD32(window);
 
     xGetSelectedExtensionEventsReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetSelectedExtensionEvents,
-        .sequenceNumber = client->sequence,
     };
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -128,13 +126,9 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
                     ClassFromMask(aclient, others->mask[i], i, NULL, CREATE);
     }
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(this_client_count);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD16(all_clients_count);
-        swapl(&rep.length);
+    REPLY_SEND();
-        swaps(&rep.this_client_count);
-        swaps(&rep.all_clients_count);
-    }
-    WriteToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep);
 
     if (total_length) {
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

Xi/getvers.c

@@ -82,22 +82,14 @@ ProcXGetExtensionVersion(ClientPtr client)
         return BadLength;
 
     xGetExtensionVersionReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetExtensionVersion,
-        .sequenceNumber = client->sequence,
         .major_version = XIVersion.major_version,
         .minor_version = XIVersion.minor_version,
         .present = TRUE
     };
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(major_version);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD16(minor_version);
-        swapl(&rep.length);
+    REPLY_SEND();
-        swaps(&rep.major_version);
-        swaps(&rep.minor_version);
-    }
-
-    WriteToClient(client, sizeof(xGetExtensionVersionReply), &rep);
-
     return Success;
 }

Xi/grabdev.c

@@ -92,9 +92,7 @@ ProcXGrabDevice(ClientPtr client)
     REQUEST_BUF_CARD32(&stuff[1], stuff->event_count);
 
     xGrabDeviceReply rep = {
-        .repType = X_Reply,
         .RepType = X_GrabDevice,
-        .sequenceNumber = client->sequence,
     };
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess);
@@ -116,11 +114,7 @@ ProcXGrabDevice(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xGrabDeviceReply), &rep);
     return Success;
 }
 

Xi/gtmotion.c

@@ -88,11 +88,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
         MaybeStopDeviceHint(dev, client);
 
     xGetDeviceMotionEventsReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceMotionEvents,
-        .sequenceNumber = client->sequence,
-        .length = 0,
-        .nEvents = 0,
         .axes = v->numAxes,
         .mode = Absolute        /* XXX we don't do relative at the moment */
     };
@@ -111,8 +107,10 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
             rep.nEvents = GetMotionHistory(dev, (xTimecoord **) &coords,   /* XXX */
                                            start.milliseconds, stop.milliseconds,
                                            (ScreenPtr) NULL, FALSE);
+            if (rep.nEvents < 0)
+                rep.nEvents = 0;
+
             length = rep.nEvents * size;
-            rep.length = bytes_to_int32(length);
         }
     }
 
@@ -123,8 +121,9 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
         swapl(&rep.nEvents);
     }
 
-    WriteToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
+    REPLY_BUF_CARD32(coords, bytes_to_int32(length));
-    WriteToClient(client, length, coords);
+    REPLY_FIELD_CARD32(nEvents);
+    REPLY_SEND_EXTRA(coords, length);
     free(coords);
     return Success;
 }

Xi/listdev.c

@@ -136,9 +136,9 @@ CopySwapButtonClass(ClientPtr client, ButtonClassPtr b, char **buf)
     b2->class = ButtonClass;
     b2->length = sizeof(xButtonInfo);
     b2->num_buttons = b->numButtons;
-    if (client && client->swapped) {
+
-        swaps(&b2->num_buttons);
+    CLIENT_STRUCT_CARD16_1(b2, num_buttons);
-    }
+
     *buf += sizeof(xButtonInfo);
 }
 
@@ -169,9 +169,8 @@ CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes, char **buf)
     else
         dev->use = IsXExtensionDevice;
 
-    if (client->swapped) {
+    CLIENT_STRUCT_CARD32_1(dev, type);
-        swapl(&dev->type);
+
-    }
     *buf += sizeof(xDeviceInfo);
 }
 
@@ -192,9 +191,9 @@ CopySwapKeyClass(ClientPtr client, KeyClassPtr k, char **buf)
     k2->min_keycode = k->xkbInfo->desc->min_key_code;
     k2->max_keycode = k->xkbInfo->desc->max_key_code;
     k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
-    if (client && client->swapped) {
+
-        swaps(&k2->num_keys);
+    CLIENT_STRUCT_CARD16_1(k2, num_keys);
-    }
+
     *buf += sizeof(xKeyInfo);
 }
 
@@ -230,9 +229,7 @@ CopySwapValuatorClass(ClientPtr client, DeviceIntPtr dev, char **buf)
         v2->num_axes = t_axes;
         v2->mode = valuator_get_mode(dev, 0);
         v2->motion_buffer_size = v->numMotionEvents;
-        if (client && client->swapped) {
+        CLIENT_STRUCT_CARD32_1(v2, motion_buffer_size);
-            swapl(&v2->motion_buffer_size);
-        }
         *buf += sizeof(xValuatorInfo);
         a = v->axes + (VPC * i);
         a2 = (xAxisInfoPtr) * buf;
@@ -240,11 +237,7 @@ CopySwapValuatorClass(ClientPtr client, DeviceIntPtr dev, char **buf)
             a2->min_value = a->min_value;
             a2->max_value = a->max_value;
             a2->resolution = a->resolution;
-            if (client && client->swapped) {
+            CLIENT_STRUCT_CARD32_3(a2, min_value, max_value, resolution);
-                swapl(&a2->min_value);
-                swapl(&a2->max_value);
-                swapl(&a2->resolution);
-            }
             a2++;
             a++;
             *buf += sizeof(xAxisInfo);
@@ -378,15 +371,12 @@ ProcXListInputDevices(ClientPtr client)
     }
 
     xListInputDevicesReply rep = {
-        .repType = X_Reply,
         .RepType = X_ListInputDevices,
-        .sequenceNumber = client->sequence,
         .ndevices = numdevs,
-        .length = bytes_to_int32(total_length),
     };
 
-    WriteReplyToClient(client, sizeof(xListInputDevicesReply), &rep);
+    REPLY_SEND_EXTRA(savbuf, total_length);
-    WriteToClient(client, total_length, savbuf);
+
     free(savbuf);
     free(skip);
     return Success;

Xi/opendev.c

@@ -131,19 +131,10 @@ ProcXOpenDevice(ClientPtr client)
     evbase[j++].event_type_base = event_base[OtherClass];
 
     xOpenDeviceReply rep = {
-        .repType = X_Reply,
         .RepType = X_OpenDevice,
-        .sequenceNumber = client->sequence,
-        .length = bytes_to_int32(j * sizeof(xInputClassInfo)),
         .num_classes = j
     };
 
-    if (client->swapped) {
+    REPLY_SEND_EXTRA(evbase, j * sizeof(xInputClassInfo));
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-
-    WriteToClient(client, sizeof(xOpenDeviceReply), &rep);
-    WriteToClient(client, j * sizeof(xInputClassInfo), evbase);
     return Success;
 }

Xi/queryst.c

@@ -68,7 +68,6 @@ ProcXQueryDeviceState(ClientPtr client)
     ValuatorClassPtr v;
     xValuatorState *tv;
     DeviceIntPtr dev;
-    double *values;
 
     REQUEST_HEAD_STRUCT(xQueryDeviceStateReq);
 
@@ -107,7 +106,6 @@ ProcXQueryDeviceState(ClientPtr client)
         tk->length = sizeof(xKeyState);
         tk->num_keys = k->xkbInfo->desc->max_key_code -
             k->xkbInfo->desc->min_key_code + 1;
-        if (rc != BadAccess)
         for (i = 0; i < 32; i++)
             tk->keys[i] = k->down[i];
         buf += sizeof(xKeyState);
@@ -132,31 +130,20 @@ ProcXQueryDeviceState(ClientPtr client)
         tv->mode |= (dev->proximity &&
                      !dev->proximity->in_proximity) ? OutOfProximity : 0;
         buf += sizeof(xValuatorState);
-        for (i = 0, values = v->axisVal; i < v->numAxes; i++) {
+        int *buf2 = (int *)buf;
+        for (i = 0; i < v->numAxes; i++) {
             if (rc != BadAccess)
-                *((int *) buf) = *values;
+                buf2[i] = v->axisVal[i];
-            values++;
-            if (client->swapped) {
-                swapl((int *) buf);
-            }
-            buf += sizeof(int);
         }
+        REPLY_BUF_CARD32(buf2, v->numAxes);
     }
 
     xQueryDeviceStateReply rep = {
-        .repType = X_Reply,
         .RepType = X_QueryDeviceState,
-        .sequenceNumber = client->sequence,
-        .length = bytes_to_int32(total_length),
         .num_classes = num_classes
     };
 
-    if (client->swapped) {
+    REPLY_SEND_EXTRA(savbuf, total_length);
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-    WriteToClient(client, sizeof(xQueryDeviceStateReply), &rep);
-    WriteToClient(client, total_length, savbuf);
     free(savbuf);
     return Success;
 }

Xi/setbmap.c

@@ -101,10 +101,6 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
         .status = (ret == Success ? MappingSuccess : MappingBusy),
     };
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-    }
-    WriteToClient(client, sizeof(xSetDeviceButtonMappingReply), &rep);
-
     return Success;
 }

Xi/setdval.c

@@ -79,9 +79,7 @@ ProcXSetDeviceValuators(ClientPtr client)
     REQUEST_HEAD_AT_LEAST(xSetDeviceValuatorsReq);
 
     xSetDeviceValuatorsReply rep = {
-        .repType = X_Reply,
         .RepType = X_SetDeviceValuators,
-        .sequenceNumber = client->sequence,
         .status = Success
     };
 
@@ -111,9 +109,6 @@ ProcXSetDeviceValuators(ClientPtr client)
     if (rep.status != Success && rep.status != AlreadyGrabbed)
         return rep.status;
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-    }
-    WriteToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
     return Success;
 }

Xi/setmmap.c

@@ -101,9 +101,6 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
         .success = ret,
     };
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-    }
-    WriteToClient(client, sizeof(xSetDeviceModifierMappingReply), &rep);
     return Success;
 }

Xi/setmode.c

@@ -79,9 +79,7 @@ ProcXSetDeviceMode(ClientPtr client)
     REQUEST_HEAD_STRUCT(xSetDeviceModeReq);
 
     xSetDeviceModeReply rep = {
-        .repType = X_Reply,
         .RepType = X_SetDeviceMode,
-        .sequenceNumber = client->sequence,
     };
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixSetAttrAccess);
@@ -112,11 +110,6 @@ ProcXSetDeviceMode(ClientPtr client)
         return rep.status;
     }
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-    }
-
-    WriteToClient(client, sizeof(xSetDeviceModeReply), &rep);
     return Success;
 }

Xi/xigetclientpointer.c

@@ -45,34 +45,24 @@
 int
 ProcXIGetClientPointer(ClientPtr client)
 {
-    int rc;
-    ClientPtr winclient;
-
     REQUEST_HEAD_STRUCT(xXIGetClientPointerReq);
     REQUEST_FIELD_CARD32(win);
 
+    ClientPtr winclient;
     if (stuff->win != None) {
-        rc = dixLookupResourceOwner(&winclient, stuff->win, client, DixGetAttrAccess);
+        if (dixLookupResourceOwner(&winclient, stuff->win, client, DixGetAttrAccess) != Success)
-
-        if (rc != Success)
             return BadWindow;
     }
     else
         winclient = client;
 
     xXIGetClientPointerReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIGetClientPointer,
-        .sequenceNumber = client->sequence,
         .set = (winclient->clientPtr != NULL),
         .deviceid = (winclient->clientPtr) ? winclient->clientPtr->id : 0
     };
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(deviceid);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND();
-        swapl(&rep.length);
-        swaps(&rep.deviceid);
-    }
-    WriteToClient(client, sizeof(xXIGetClientPointerReply), &rep);
     return Success;
 }

Xi/xigrabdev.c

@@ -110,17 +110,12 @@ ProcXIGrabDevice(ClientPtr client)
         return ret;
 
     xXIGrabDeviceReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIGrabDevice,
-        .sequenceNumber = client->sequence,
         .status = status
     };
 
-    if (client->swapped) {
+    REPLY_SEND();
-        swaps(&rep.sequenceNumber);
+    return Success;
-    }
-    WriteToClient(client, sizeof(rep), &rep);
-    return ret;
 }
 
 int

Xi/xipassivegrab.c

@@ -51,13 +51,6 @@ int
 ProcXIPassiveGrabDevice(ClientPtr client)
 {
     DeviceIntPtr dev, mod_dev;
-    xXIPassiveGrabDeviceReply rep = {
-        .repType = X_Reply,
-        .RepType = X_XIPassiveGrabDevice,
-        .sequenceNumber = client->sequence,
-        .length = 0,
-        .num_modifiers = 0
-    };
     int i, ret = Success;
     uint32_t *modifiers;
     xXIGrabModifierInfo *modifiers_failed = NULL;
@@ -185,6 +178,8 @@ ProcXIPassiveGrabDevice(ClientPtr client)
 
     mod_dev = (InputDevIsFloating(dev)) ? dev : GetMaster(dev, MASTER_KEYBOARD);
 
+    int num_mod = 0;
+
     for (i = 0; i < stuff->num_modifiers; i++, modifiers++) {
         uint8_t status = Success;
 
@@ -221,27 +216,24 @@ ProcXIPassiveGrabDevice(ClientPtr client)
         }
 
         if (status != GrabSuccess) {
-            xXIGrabModifierInfo *info = modifiers_failed + rep.num_modifiers;
+            xXIGrabModifierInfo *info = modifiers_failed + num_mod;
 
             info->status = status;
             info->modifiers = *modifiers;
-            if (client->swapped)
+            CLIENT_STRUCT_CARD32_1(info, modifiers);
-                swapl(&info->modifiers);
+            num_mod++;
-
-            rep.num_modifiers++;
-            rep.length += bytes_to_int32(sizeof(xXIGrabModifierInfo));
         }
     }
 
-    uint32_t length = rep.length; /* save it before swapping */
+    xXIPassiveGrabDeviceReply rep = {
+        .RepType = X_XIPassiveGrabDevice,
+        .num_modifiers = num_mod,
+    };
 
-    if (client->swapped) {
+    uint32_t length = bytes_to_int32(sizeof(xXIGrabModifierInfo) * num_mod);
-        swaps(&rep.sequenceNumber);
+
-        swapl(&rep.length);
+    REPLY_FIELD_CARD16(num_modifiers);
-        swaps(&rep.num_modifiers);
+    REPLY_SEND_EXTRA(modifiers_failed, length * 4);
-    }
-    WriteToClient(client, sizeof(rep), &rep);
-    WriteToClient(client, length * 4, modifiers_failed);
 
  out:
     free(modifiers_failed);

Xi/xiproperty.c

@@ -853,11 +853,10 @@ ProcXListDeviceProperties(ClientPtr client)
     Atom *atoms;
     int natoms;
     DeviceIntPtr dev;
-    int rc = Success;
 
     REQUEST_HEAD_STRUCT(xListDevicePropertiesReq);
 
-    rc = dixLookupDevice(&dev, stuff->deviceid, client, DixListPropAccess);
+    int rc = dixLookupDevice(&dev, stuff->deviceid, client, DixListPropAccess);
     if (rc != Success)
         return rc;
 
@@ -866,25 +865,17 @@ ProcXListDeviceProperties(ClientPtr client)
         return rc;
 
     xListDevicePropertiesReply rep = {
-        .repType = X_Reply,
         .RepType = X_ListDeviceProperties,
         .sequenceNumber = client->sequence,
         .length = natoms,
         .nAtoms = natoms
     };
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(nAtoms);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND();
-        swapl(&rep.length);
-        swaps(&rep.nAtoms);
-    }
-    WriteToClient(client, sizeof(xListDevicePropertiesReply), &rep);
-    if (natoms) {
-        client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-        WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);
     free(atoms);
-    }
+
-    return rc;
+    return Success;
 }
 
 int
@@ -976,9 +967,7 @@ ProcXGetDeviceProperty(ClientPtr client)
         return rc;
 
     xGetDevicePropertyReply rep = {
-        .repType = X_Reply,
         .RepType = X_GetDeviceProperty,
-        .sequenceNumber = client->sequence,
         .length = bytes_to_int32(length),
         .propertyType = type,
         .bytesAfter = bytes_after,
@@ -990,14 +979,10 @@ ProcXGetDeviceProperty(ClientPtr client)
     if (stuff->delete && (rep.bytesAfter == 0))
         send_property_event(dev, stuff->property, XIPropertyDeleted);
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD32(propertyType);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD32(bytesAfter);
-        swapl(&rep.length);
+    REPLY_FIELD_CARD32(nItems);
-        swapl(&rep.propertyType);
+    REPLY_SEND();
-        swapl(&rep.bytesAfter);
-        swapl(&rep.nItems);
-    }
-    WriteToClient(client, sizeof(xGenericReply), &rep);
 
     if (length) {
         switch (rep.format) {
@@ -1051,19 +1036,14 @@ ProcXIListProperties(ClientPtr client)
         return rc;
 
     xXIListPropertiesReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIListProperties,
-        .sequenceNumber = client->sequence,
         .length = natoms,
         .num_properties = natoms
     };
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(num_properties);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND();
-        swapl(&rep.length);
+
-        swaps(&rep.num_properties);
-    }
-    WriteToClient(client, sizeof(xXIListPropertiesReply), &rep);
     if (natoms) {
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
         WriteSwappedDataToClient(client, natoms * sizeof(Atom), atoms);
@@ -1165,9 +1145,7 @@ ProcXIGetProperty(ClientPtr client)
         return rc;
 
     xXIGetPropertyReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIGetProperty,
-        .sequenceNumber = client->sequence,
         .length = bytes_to_int32(length),
         .type = type,
         .bytes_after = bytes_after,
@@ -1178,14 +1156,10 @@ ProcXIGetProperty(ClientPtr client)
     if (length && stuff->delete && (rep.bytes_after == 0))
         send_property_event(dev, stuff->property, XIPropertyDeleted);
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD32(type);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD32(bytes_after);
-        swapl(&rep.length);
+    REPLY_FIELD_CARD32(num_items);
-        swapl(&rep.type);
+    REPLY_SEND();
-        swapl(&rep.bytes_after);
-        swapl(&rep.num_items);
-    }
-    WriteToClient(client, sizeof(xXIGetPropertyReply), &rep);
 
     if (length) {
         switch (rep.format) {

Xi/xiquerydevice.c

@@ -101,12 +101,11 @@ ProcXIQueryDevice(ClientPtr client)
     }
 
     xXIQueryDeviceReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIQueryDevice,
-        .sequenceNumber = client->sequence,
-        .length = len / 4,
     };
 
+    int buf_len = len;
+
     ptr = info;
     if (dev) {
         len = ListDeviceInfo(client, dev, (xXIDeviceInfo *) info);
@@ -138,15 +137,9 @@ ProcXIQueryDevice(ClientPtr client)
         }
     }
 
-    len = rep.length * 4;
+    REPLY_FIELD_CARD16(num_devices);
+    REPLY_SEND_EXTRA(ptr, buf_len);
 
-    if (client->swapped) {
-        swaps(&rep.sequenceNumber);
-        swapl(&rep.length);
-        swaps(&rep.num_devices);
-    }
-    WriteToClient(client, sizeof(xXIQueryDeviceReply), &rep);
-    WriteToClient(client, len, ptr);
     free(ptr);
     free(skip);
     return rc;

Xi/xiquerypointer.c

@@ -115,9 +115,7 @@ ProcXIQueryPointer(ClientPtr client)
     pSprite = pDev->spriteInfo->sprite;
 
     xXIQueryPointerReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIQueryPointer,
-        .sequenceNumber = client->sequence,
         .length = 6,
         .root = (InputDevCurrentRootWindow(pDev))->drawable.id,
         .root_x = double_to_fp1616(pSprite->hot.x),
@@ -183,19 +181,14 @@ ProcXIQueryPointer(ClientPtr client)
     }
 #endif /* XINERAMA */
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD32(root);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD32(child);
-        swapl(&rep.length);
+    REPLY_FIELD_CARD32(root_x);
-        swapl(&rep.root);
+    REPLY_FIELD_CARD32(root_y);
-        swapl(&rep.child);
+    REPLY_FIELD_CARD32(win_x);
-        swapl(&rep.root_x);
+    REPLY_FIELD_CARD32(win_y);
-        swapl(&rep.root_y);
+    REPLY_FIELD_CARD16(buttons_len);
-        swapl(&rep.win_x);
+    REPLY_SEND_EXTRA(buttons, buttons_size);
-        swapl(&rep.win_y);
-        swaps(&rep.buttons_len);
-    }
-    WriteToClient(client, sizeof(xXIQueryPointerReply), &rep);
-    WriteToClient(client, buttons_size, buttons);
 
     free(buttons);
 

Xi/xiqueryversion.c

@@ -115,19 +115,12 @@ ProcXIQueryVersion(ClientPtr client)
     }
 
     xXIQueryVersionReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIQueryVersion,
-        .sequenceNumber = client->sequence,
         .major_version = major,
         .minor_version = minor
     };
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(major_version);
-        swaps(&rep.sequenceNumber);
+    REPLY_FIELD_CARD16(minor_version);
-        swaps(&rep.major_version);
-        swaps(&rep.minor_version);
-    }
-    WriteToClient(client, sizeof(xXIQueryVersionReply), &rep);
-
     return Success;
 }

Xi/xiselectev.c

@@ -135,8 +135,7 @@ ProcXISelectEvents(ClientPtr client)
             if (len < bytes_to_int32(sizeof(xXIEventMask)))
                 return BadLength;
             len -= bytes_to_int32(sizeof(xXIEventMask));
-            swaps(&evmask->deviceid);
+            CLIENT_STRUCT_CARD16_2(evmask, deviceid, mask_len);
-            swaps(&evmask->mask_len);
             if (len < evmask->mask_len)
                 return BadLength;
             len -= evmask->mask_len;
@@ -338,9 +337,7 @@ ProcXIGetSelectedEvents(ClientPtr client)
         return rc;
 
     xXIGetSelectedEventsReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIGetSelectedEvents,
-        .sequenceNumber = client->sequence,
     };
 
     masks = wOtherInputMasks(win);
@@ -377,12 +374,9 @@ ProcXIGetSelectedEvents(ClientPtr client)
                 evmask->deviceid = i;
                 evmask->mask_len = mask_len;
                 rep.num_masks++;
-                rep.length += sizeof(xXIEventMask) / 4 + evmask->mask_len;
+                length += sizeof(xXIEventMask) + mask_len * 4;
 
-                if (client->swapped) {
+                CLIENT_STRUCT_CARD16_2(evmask, deviceid, mask_len);
-                    swaps(&evmask->deviceid);
-                    swaps(&evmask->mask_len);
-                }
 
                 memcpy(&evmask[1], devmask, j + 1);
                 evmask = (xXIEventMask *) ((char *) evmask +
@@ -395,13 +389,7 @@ ProcXIGetSelectedEvents(ClientPtr client)
 finish: ;
     uint32_t length = rep.length; /* save before swapping it */
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD16(num_masks);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND_EXTRA(buffer, length);
-        swapl(&rep.length);
-        swaps(&rep.num_masks);
-    }
-    WriteToClient(client, sizeof(xXIGetSelectedEventsReply), &rep);
-    WriteToClient(client, length * 4, buffer);
-
     return Success;
 }

Xi/xisetdevfocus.c

@@ -78,9 +78,7 @@ ProcXIGetFocus(ClientPtr client)
         return BadDevice;
 
     xXIGetFocusReply rep = {
-        .repType = X_Reply,
         .RepType = X_XIGetFocus,
-        .sequenceNumber = client->sequence,
     };
 
     if (dev->focus->win == NoneWin)
@@ -92,11 +90,7 @@ ProcXIGetFocus(ClientPtr client)
     else
         rep.focus = dev->focus->win->drawable.id;
 
-    if (client->swapped) {
+    REPLY_FIELD_CARD32(focus);
-        swaps(&rep.sequenceNumber);
+    REPLY_SEND();
-        swapl(&rep.length);
-        swapl(&rep.focus);
-    }
-    WriteToClient(client, sizeof(xXIGetFocusReply), &rep);
     return Success;
 }