/* $XConsortium: pack.c /main/5 1995/07/15 20:38:40 drk $ */

/*

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 * 

 */

/*

 * HISTORY

 */

#include "wsm_proto.h"

/* this will redifine bzero to memset if needed. */

#include <Xm/XmosP.h>

#define COUNT_SIZE (sizeof(CARD16))

#define BOOL_SIZE  1		/* at least 1 byte for a boolean. */

/*

 * More intuitive names for various functions.

 */

#define PackBoolean(d, num)	PackCARD8((d), (CARD8) (num))

#define PackListNum(d, num)	PackCARD16((d), (CARD16) (num))

#define PackWindow(d, num)	PackCARD32((d), (CARD32) (num))

#define PackProperty(d, num)	PackCARD32((d), (CARD32) (num))

#define UnpackBoolean(data)	((Boolean) UnpackCARD8(data))

#define UnpackListNum(data)	((int) UnpackCARD16(data))

#define UnpackWindow(data)	((Window) UnpackCARD32(data))

#define UnpackProperty(data)	((WindowProperty) UnpackCARD32(data))

#define START_CHECK_MASK 0x80

/************************************************************

 *

 *  Function definitions.

 *

 ************************************************************/

/*

 * Routines for getting the amount of space that a request will take in the

 * protocol data stream.

 */

static int WinInfoSizePacked(Display *, int, WSMWinInfo *);

static int WinEntrySizePacked(Display *, int, WSMWinEntry *);

static int WinDataSizePacked(Display *, int,

			     WSMWinData *, int, WSMConfigFormatType);

/*

 * Routines for packing protocol data stream.

 */

   static    MessageData PackConfigFormat(MessageData, WSMConfigFormatReply *);

   static    MessageData PackSingleAttribute(MessageData, WSMAttribute *, int);

   static    MessageData PackWinInfo(Display *, int, MessageData,

				     WSMWinInfo *);

   static    MessageData PackWinEntry(Display *, int, MessageData,

				      WSMWinEntry *);

   static    MessageData PackWinData(Display *, int, MessageData, 

			       WSMWinData *, int, WSMConfigFormatType);

/* public */ MessageData PackCARD16(MessageData, CARD16);

/* public */ MessageData PackCARD8(MessageData, CARD8);

/* public */ MessageData PackString(MessageData, String);

/* public */ MessageData PackCARD32(MessageData, CARD32);

/*

 * Routines for unpacking protocol data stream.

 */

static void UnpackWinData(MessageData *, Display *, 

			  int, WSMConfigFormatType, WSMWinData **, int *);

static void UnpackSingleWinDataRec(MessageData *, WSMAttribute *,WSMWinData *);

static void UnpackWinInfo(MessageData *, Display *, int, WSMWinInfo *);

static void UnpackWinEntry(MessageData *, Display *, int, WSMWinEntry *);

/* public */ String UnpackString(MessageData *);

/* public */ CARD32 UnpackCARD32(MessageData *);

/* public */ CARD16 UnpackCARD16(MessageData *);

/* public */ CARD8  UnpackCARD8(MessageData *);

/************************************************************

 *

 *  These two routines take data stored in a structure that

 *  humans can understand and pack it down into nice little

 *  protocol requests defined by the OSF WSM Protocol spec.

 *

 ************************************************************/

/*	Function Name: _WSMPackRequest

 *	Description: Packs up the request passed into an appropriate

 *                   message data structure.

 *	Arguments: dpy - the display we will be sending this message on.

 *                 screen_num - The screen we will be sending this message to.

 *                 request - request to send.

 * RETURNED        msg_data_len - The length of the message data.

 * RETURNED        error - An error code if something went wrong.

 *	Returns: A pointer to a message data struct.

 * 

 * NOTE: The message data struct must be freed by the calling routine.

 */

MessageData 

_WSMPackRequest(Display *dpy, int screen_num, WSMRequest *request,

		unsigned long *msg_data_len, WSMErrorCode *error)

{

    MessageData data, save;

    int i;

    long size;

    WSMWinInfo *win_info;

    WSMConfigFormatData *global_attrs, *win_attrs, *icon_attrs;

    *msg_data_len = 0;		/* default value. */

    global_attrs = _WSMGetConfigFormat(dpy, screen_num, WSM_GLOBAL_FMT);

    win_attrs = _WSMGetConfigFormat(dpy, screen_num, WSM_WINDOW_FMT);

    icon_attrs = _WSMGetConfigFormat(dpy, screen_num, WSM_ICON_FMT);

    *error = WSM_SUCCESS;

    if (_WSMRequiresConfigFormat(request->any.type) && 

	(global_attrs->num_attrs == 0) && 

	(win_attrs->num_attrs == 0) && (icon_attrs->num_attrs == 0))

    {

	*error = WSM_ERROR_NO_CONFIG_FORMAT;

	return(NULL);

    }

    if (((request->any.type == WSM_CONNECT) ||

	 (request->any.type == WSM_CONFIG_FMT)) &&

	((global_attrs->num_attrs != 0) ||

	 (win_attrs->num_attrs != 0) || (icon_attrs->num_attrs != 0)))

    {

	*error = WSM_ERROR_ALREADY_HAVE_CONFIG_FORMAT;

	return(NULL);

    }

    /* before sending extensions make sure screen_info config format

       is cleared */

    /* may want to remove this and leave it up to application writer */

    if ((request->any.type == WSM_EXTENSIONS) && 

	((global_attrs->num_attrs != 0) ||

	 (win_attrs->num_attrs != 0) || (icon_attrs->num_attrs != 0)))

      {

	_WSMClearConfigScreenInfo(dpy,screen_num);

      }

    /*

     *  Calculate the size of the request.

     */

    switch (request->any.type) {

    case WSM_CONNECT:

	size = COUNT_SIZE;

	size += sizeof(CARD8) * request->connect.num_versions;

	break;

    case WSM_EXTENSIONS:

	size = COUNT_SIZE;

	for (i = 0; i < request->extensions.num_extensions; i++) {

	    size += (strlen(request->extensions.extension_suggestions[i]) +

		     COUNT_SIZE);

	}

	break;

    case WSM_CONFIG_FMT:

	size = 0;

	break;

    case WSM_GET_STATE:

	size = sizeof(CARD32) + BOOL_SIZE;

	break;

    case WSM_SET_STATE:

	size = COUNT_SIZE;	/* The count of window info. */

	win_info = request->set_state.win_info_list;

	for (i = 0; i < request->set_state.num_win_info_list; i++,win_info++)

	    size += WinInfoSizePacked(dpy, screen_num, win_info);

	break;

    case WSM_REG_WINDOW:

	size = sizeof(CARD32);

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	size = sizeof(CARD16);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	size = sizeof(CARD32);

	break;

    case WSM_WM_WINDOWS:

	size = sizeof(CARD32); /* flag */

	size += COUNT_SIZE;    /* prop count */

	size += request->wm_windows.num_window_properties * sizeof(Window);

	size += COUNT_SIZE;    /* num match attributes */

	for (i=0; i<request->wm_windows.num_match_attributes; i++)

	  {

	    size += COUNT_SIZE; /* num attributes */

	    size += 2 *

	            request->wm_windows.match_attributes[i]->num_attributes *

		    sizeof(WindowProperty);

	  }

	break;

    case WSM_WM_FOCUS:

	size = 0;

	break;

    case WSM_WM_POINTER:

	size = 0;

	break;

    default:

	return(NULL);

    }

    save = data = (MessageData) XtMalloc(size);

    /*

     * Fill in the message.

     */

    switch (request->any.type) {

    case WSM_CONNECT:

	data = PackListNum(data, request->connect.num_versions);

	for (i = 0; i < request->connect.num_versions; i++) 

	    data = PackCARD8(data, (CARD8) request->connect.known_versions[i]);

	break;

    case WSM_EXTENSIONS:

	data = PackListNum(data, request->extensions.num_extensions);

	for (i = 0; i < request->extensions.num_extensions; i++) 

	    data=PackString(data,request->extensions.extension_suggestions[i]);

	break;

    case WSM_CONFIG_FMT:

	break;

    case WSM_GET_STATE:

	data = PackWindow(data, request->get_state.window);

	(void) PackBoolean(data, request->get_state.diffs_allowed);

	break;

    case WSM_SET_STATE:

	win_info = request->set_state.win_info_list;

	data = PackListNum(data, request->set_state.num_win_info_list);

	for (i = 0; i < request->set_state.num_win_info_list; i++, win_info++)

	    data = PackWinInfo(dpy, screen_num, data, win_info);

	break;

    case WSM_REG_WINDOW:

	(void) PackWindow(data, request->register_window.window);

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	(void) PackCARD16(data, request->get_background.screen);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	(void) PackWindow(data, request->set_background.window);

	break;

    case WSM_WM_WINDOWS:

	{

	  int i, j;

	  data = PackCARD32(data, request->wm_windows.location_flag);

	  data = PackListNum(data, request->wm_windows.num_window_properties);

	  for (i=0; i<request->wm_windows.num_window_properties; i++)

	    data = PackProperty(data, request->wm_windows.window_properties[i]);

	  data = PackListNum(data, request->wm_windows.num_match_attributes);

	  for (i = 0;  i < request->wm_windows.num_match_attributes;  i++)

	    {

	      AttributePair *match_attr;

	      match_attr = request->wm_windows.match_attributes[i];

	      data = PackListNum(data, match_attr->num_attributes);

	      for (j = 0;  j < match_attr->num_attributes;  j++)

		data = PackProperty(data, match_attr->allowed_attributes[j]);

	      for (j = 0;  j < match_attr->num_attributes;  j++)

		data = PackProperty(data, match_attr->prohibited_attributes[j]);

	    }

	}

	break;

    case WSM_WM_FOCUS:

	break;

    case WSM_WM_POINTER:

	break;

    default:

	break;

    }

    *msg_data_len = size;

    return(save);

} /* _WSMPackRequest */

/*	Function Name: _WSMPackReply

 *	Description: Packs up the Reply passed into an appropriate

 *                   message data structure.

 *	Arguments: dpy - the display we will be sending this message on.

 *                 screen_num - The screen we will be sending this message to.

 *                 reply - reply to send.

 * RETURNED        msg_data_len - The length of the message data.

 *	Returns: A pointer to a message data struct.

 * 

 * NOTE: The message data struct must be freed by the calling routine.

 */

MessageData 

_WSMPackReply(Display *dpy, int screen_num,

	      WSMReply *reply, unsigned long *msg_data_len)

{

    WSMAttribute *attr;

    WSMWinInfo *win_info;

    WSMWinEntry *win_entry;

    register int i;

    long size;

    MessageData data, save;

    *msg_data_len = 0;		/* default value. */

    switch (reply->any.type) {

    case WSM_CONNECT:

	size = sizeof(CARD8);

	break;

    case WSM_EXTENSIONS:

	size = COUNT_SIZE;

	for (i = 0; i < reply->extensions.num_extensions; i++) {

	    size += (strlen(reply->extensions.extensions[i]) + COUNT_SIZE);

	}

	break;

    case WSM_CONFIG_FMT:

	size = BOOL_SIZE;	/* accept_diffs. */

	size += COUNT_SIZE;	/* The count of global attributes. */

	attr = reply->config_format.global_formats;

	for (i = 0; i < reply->config_format.num_global_formats; i++)  {

	    /*

	     * Bytes in string

	     */

	    size += strlen(XrmQuarkToString(attr[i].nameq)) * sizeof(CARD8);

	    /*

	     * len of string + size + is_list.

	     */

	    size += COUNT_SIZE + sizeof(CARD8) + BOOL_SIZE; 

	}

	size += COUNT_SIZE;	/* The count of window attributes. */

	attr = reply->config_format.window_formats;

	for (i = 0; i < reply->config_format.num_window_formats; i++)  {

	    /*

	     * Bytes in string

	     */

	    size += strlen(XrmQuarkToString(attr[i].nameq)) * sizeof(CARD8);

	    /*

	     * len of string + size + is_list.

	     */

	    size += COUNT_SIZE + sizeof(CARD8) + BOOL_SIZE; 

	}

	size += COUNT_SIZE;	/* The count of icon attributes. */

	attr = reply->config_format.icon_formats;

	for (i = 0; i < reply->config_format.num_icon_formats; i++)  {

	    /*

	     * Bytes in string

	     */

	    size += strlen(XrmQuarkToString(attr[i].nameq)) * sizeof(CARD8);

	    /*

	     * len of string + size + is_list.

	     */

	    size += COUNT_SIZE + sizeof(CARD8) + BOOL_SIZE; 

	}

	break;

    case WSM_GET_STATE:

	size = COUNT_SIZE;	/* The count of window info. */

	win_info = reply->get_state.win_info_list;

	for (i = 0; i < reply->get_state.num_win_info_list; i++,win_info++)

	    size += WinInfoSizePacked(dpy, screen_num, win_info);

	break;

    case WSM_SET_STATE:

	size = 0;

	break;

    case WSM_REG_WINDOW:

	size = WinDataSizePacked(dpy, screen_num, 

				 reply->register_window.window_data,

				 reply->register_window.num_window_data,

				 WSM_WINDOW_FMT);

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	size = sizeof(CARD32);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	size = sizeof(CARD32);

	break;

    case WSM_WM_WINDOWS:

	size = COUNT_SIZE;	/* The count of window entries. */

	win_entry = reply->wm_windows.win_entry_list;

	for (i = 0; i < reply->wm_windows.num_win_entry_list; i++,win_entry++)

	    size += WinEntrySizePacked(dpy, screen_num, win_entry);

	break;

    case WSM_WM_FOCUS:

	size = sizeof(CARD32);

	break;

    case WSM_WM_POINTER:

	size  = sizeof(CARD32); /* window */

	size += sizeof(CARD32); /* flag */

	break;

    default:

	/*

	 * ||| Error Message.

	 */

	return(NULL);

    }

    save = data = (MessageData) XtMalloc(size);

    switch (reply->any.type) {

    case WSM_CONNECT:

	(void) PackCARD8(data, (CARD8) (reply->connect.version & 0xFF));

	break;

    case WSM_EXTENSIONS:

	data = PackListNum(data, reply->extensions.num_extensions);

	for (i = 0; i < reply->extensions.num_extensions; i++) 

	    data = PackString(data, reply->extensions.extensions[i]);

	break;

    case WSM_CONFIG_FMT:

	PackConfigFormat(data, &(reply->config_format));

	break;

    case WSM_GET_STATE:

	win_info = reply->get_state.win_info_list;

	data = PackListNum(data, reply->get_state.num_win_info_list);

	for (i = 0; i < reply->get_state.num_win_info_list; i++, win_info++)

	    data = PackWinInfo(dpy, screen_num, data, win_info);

	break;

    case WSM_SET_STATE:

	break;

    case WSM_REG_WINDOW:

	data = PackWinData(dpy, screen_num, data, 

			   reply->register_window.window_data,

			   reply->register_window.num_window_data,

			   WSM_WINDOW_FMT);

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	(void) PackWindow(data, reply->get_background.window);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	(void) PackWindow(data, reply->set_background.window);

	break;

    case WSM_WM_WINDOWS:

	win_entry = reply->wm_windows.win_entry_list;

	data = PackListNum(data, reply->wm_windows.num_win_entry_list);

	for (i = 0; i < reply->wm_windows.num_win_entry_list; i++, win_entry++)

	    data = PackWinEntry(dpy, screen_num, data, win_entry);

	break;

    case WSM_WM_FOCUS:

	(void) PackWindow(data, reply->wm_focus.window);

	break;

    case WSM_WM_POINTER:

	(void) PackWindow(data, reply->wm_pointer.window);

	(void) PackCARD32(data, reply->wm_pointer.location_flag);

	break;

    default:

	break;

    }

    *msg_data_len = size;

    return(save);

}/* _WSMPackReply */

/************************************************************

 *

 *  These routines take data on the wire and put it into a structure

 *  that can be manipulated by the app.

 *

 ************************************************************/

/*	Function Name: _WSMUnpackRequest

 *	Description: Unpacks the byte stream from the wire into a request

 *                   message structure.

 *	Arguments: dpy - The Display.

 *                 screen_num - The Screen number.

 *                 data - The bits from accross the wire.

 *                 len - The number of bits sent - Better error checking

 *                       makes this more necessary.

 *                 type - The type of message received.

 * RETURNED        request - This request structure is filled in with the data

 *                         unpacked from the protocol.

 *	Returns: none.

 */

/*ARGSUSED*/

void

_WSMUnpackRequest(Display *dpy, int screen_num, MessageData data, 

		  unsigned long len, WSMRequestType type, WSMRequest *request)

{

    register int i;

    request->any.type = type;	/* Save the type. */

    request->any.allocated = False;

    switch (request->any.type) {

    case WSM_CONNECT:

	request->connect.num_versions = UnpackListNum(&data);

	request->connect.known_versions =

	    (short *) XtMalloc(sizeof(short) * request->connect.num_versions);

	request->connect.allocated = True;

	for (i = 0; i < request->connect.num_versions; i++) 

	    request->connect.known_versions[i] = (short) UnpackCARD8(&data);

	break;

    case WSM_EXTENSIONS:

        {

	    register int num;

	    register String *ptr;

	    num = request->extensions.num_extensions = UnpackListNum(&data);

	    ptr = (String *) XtMalloc(sizeof(String) * num);

	    request->extensions.extension_suggestions = ptr;

	    request->extensions.allocated = True;

	    for (i = 0; i < num; i++, ptr++) 

		*ptr = UnpackString(&data);

	}

	break;

    case WSM_CONFIG_FMT:

	break;

    case WSM_GET_STATE:

	request->get_state.window = UnpackWindow(&data);

	request->get_state.diffs_allowed = UnpackBoolean(&data);

	break;

    case WSM_SET_STATE:

        {

	    int num = UnpackListNum(&data);

	    request->set_state.num_win_info_list = num;

	    request->set_state.win_info_list = 

		(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);

	    request->extensions.allocated = True;

	    for (i = 0; i < num; i++) {

		UnpackWinInfo(&data, dpy, screen_num, 

			      request->set_state.win_info_list + i);

	    }

	}

	break;

    case WSM_REG_WINDOW:

	request->register_window.window = UnpackWindow(&data);	

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	request->get_background.screen = (int)UnpackCARD16(&data);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	request->set_background.window = UnpackWindow(&data);

	break;

    case WSM_WM_WINDOWS:

	{

	  int num, i, j;

	  request->extensions.allocated = True;

	  request->wm_windows.location_flag = UnpackCARD32(&data);

	  num = request->wm_windows.num_window_properties = UnpackListNum(&data);

	  request->wm_windows.window_properties =

	    (WindowProperty *) XtMalloc(sizeof(WindowProperty) * num);

	  for (i=0; i

	    request->wm_windows.window_properties[i] = UnpackProperty(&data);

	  num = request->wm_windows.num_match_attributes = UnpackListNum(&data);

	  request->wm_windows.match_attributes =

	    (AttributePair **) XtMalloc(sizeof(AttributePair*) * num);

	  for (i=0; i<request->wm_windows.num_match_attributes; i++)

	    {

	      num = UnpackListNum(&data);

	      request->wm_windows.match_attributes[i] = (AttributePair *)

		XtMalloc(sizeof(AttributePair) * num * 2 + sizeof(int));

	      request->wm_windows.match_attributes[i]->num_attributes = num;

	      for (j=0; j

		{

		  request->wm_windows.match_attributes[i]->allowed_attributes[j] =

		    UnpackProperty(&data);

		}

	      for (j=0; j

		{

		  request->wm_windows.match_attributes[i]->prohibited_attributes[j] =

		    UnpackProperty(&data);

		}

	    }

	}

	break;

    case WSM_WM_FOCUS:

	break;

    case WSM_WM_POINTER:

	break;

    default:

	break;

    }

} /* _WSMUnpackRequest */

/*	Function Name: _WSMUnpackReply

 *	Description: Unpacks the byte stream from the wire into a reply

 *                   message structure.

 *	Arguments: dpy - The Display.

 *                 screen_num - The Screen number.

 *                 data - the bits from accross the wire.

 *                 len - The number of bits sent - Better error checking

 *                       makes this more necessary.

 *                 type - The type of message received.

 * RETURNED        reply - This reply structure is filled in with the data

 *                         unpacked from the protocol.

 *	Returns: none.

 */

/*ARGSUSED*/

void

_WSMUnpackReply(Display *dpy, int screen_num, MessageData data, 

		unsigned long len, WSMRequestType type, WSMReply *reply)

{

    register int i;

    reply->any.type = type;		/* Save the type. */

    reply->any.allocated = False;

    switch (reply->any.type) {

    case WSM_CONNECT:

        if (data != NULL)

	  reply->connect.version = (short) UnpackCARD8(&data);

	else

	  fprintf(stderr, "Error - Connection request reply data is empty!\n");

	break;

    case WSM_EXTENSIONS:

        {

	    register int num;

	    register String *ptr;

	    num = reply->extensions.num_extensions = UnpackListNum(&data);

	    ptr = (String *) XtMalloc(sizeof(String) * num);

	    reply->extensions.allocated = True;

	    reply->extensions.extensions = ptr;

	    for (i = 0; i < num; i++, ptr++) 

		*ptr = UnpackString(&data);

	}

	break;

    case WSM_CONFIG_FMT:

        {

	    register int types;

	    WSMConfigFormatReply * config_format = &(reply->config_format);

	    WSMConfigFormatData *fmt;

	    WSMScreenInfo *scr_info = _WSMGetScreenInfo(dpy, screen_num);

	    config_format->accepts_diffs = UnpackBoolean(&data);

	    for (types = 0; types < 3; types++) {

		switch(types) {

		case WSM_GLOBAL_FMT:

		    fmt = &(scr_info->global);

		    break;

		case WSM_WINDOW_FMT:

		    fmt = &(scr_info->window);

		    break;

		case WSM_ICON_FMT:

		    fmt = &(scr_info->icon);

		    break;

		}

		fmt->num_attrs = UnpackListNum(&data);

		fmt->attr_list = (WSMAttribute *) 

		    XtMalloc(sizeof(WSMAttribute) * fmt->num_attrs);

		for (i = 0; i < fmt->num_attrs; i++) {

		    String str = UnpackString(&data);

		    fmt->attr_list[i].nameq = XrmStringToQuark(str);

		    XtFree(str);

		    fmt->attr_list[i].size = UnpackCARD8(&data);

		    fmt->attr_list[i].is_list = UnpackCARD8(&data);

		}

	    }

	    /*

	     * No need to allocate this, since they are just pointers

	     * back to global data.

	     */

	    config_format->global_formats = scr_info->global.attr_list;

	    config_format->num_global_formats = scr_info->global.num_attrs;

	    config_format->window_formats = scr_info->window.attr_list;

	    config_format->num_window_formats = scr_info->window.num_attrs;

	    config_format->icon_formats = scr_info->icon.attr_list;

	    config_format->num_icon_formats = scr_info->icon.num_attrs;

	}

	break;

    case WSM_GET_STATE:

	{

	    int num =reply->get_state.num_win_info_list = UnpackListNum(&data);

	    reply->get_state.win_info_list = 

		(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);

	    reply->get_state.allocated = True;

	    for (i = 0; i < num; i++) 

		UnpackWinInfo(&data, dpy, screen_num, 

			      reply->get_state.win_info_list + i);

	}

	break;

    case WSM_SET_STATE:

	break;

    case WSM_REG_WINDOW:

	if (data != NULL)

	  {

	    UnpackWinData(&data, dpy, screen_num, WSM_WINDOW_FMT,

			  &(reply->register_window.window_data),

			  &(reply->register_window.num_window_data));

	    reply->register_window.allocated = True;

	  }

	else

	  fprintf(stderr, "Error - Register Window reply data is empty!\n");

	break;

    case WSM_WM_GET_BACKGROUND_WINDOW:

	reply->get_background.window = UnpackWindow(&data);

	break;

    case WSM_WM_SET_BACKGROUND_WINDOW:

	reply->set_background.window = UnpackWindow(&data);

	break;

    case WSM_WM_WINDOWS:

	{

	  int num;

	  num = reply->wm_windows.num_win_entry_list = UnpackListNum(&data);

	  reply->wm_windows.win_entry_list = 

	    (WSMWinEntry *) XtMalloc(sizeof(WSMWinEntry) * num);

	  reply->wm_windows.allocated = True;

	  for (i = 0; i < num; i++) 

	    UnpackWinEntry(&data, dpy, screen_num, 

			   reply->wm_windows.win_entry_list + i);

	}

	break;

    case WSM_WM_FOCUS:

	reply->wm_focus.window = UnpackWindow(&data);

	break;

    case WSM_WM_POINTER:

	reply->wm_pointer.location_flag = UnpackCARD32(&data);

	break;

    default:

	break;

    }

} /* _WSMUnpackReply */

/************************************************************

 *

 *  Internal Routines for getting size of packed requests.

 *

 ************************************************************/

/*	Function Name: WinInfoSizePacked

 *	Description: Returns the size this window structure will take

 *                   when packed into a protocol data stream.

 *	Arguments: dpy, screen_num - The display and screen of the client we 

 *                                   are talking to.

 *                 win_info - The window info whose size me are checking.

 *	Returns: the size (in bytes)

 */

static int 

WinInfoSizePacked(Display *dpy, int screen_num, WSMWinInfo *win_info)

{

    int size = sizeof(CARD32);

    size += WinDataSizePacked(dpy, screen_num, 

			      win_info->data_list, win_info->num_data_list,

			      _WSMGetConfigFormatType(win_info->window));

    return(size);

}

/*	Function Name: WinEntrySizePacked

 *	Description: Returns the size this window structure will take

 *                   when packed into a protocol data stream.

 *	Arguments: dpy, screen_num - The display and screen of the client we 

 *                                   are talking to.

 *                 win_entry - The window entry whose size we are checking.

 *	Returns: the size (in bytes)

 */

static int 

WinEntrySizePacked(Display *dpy, int screen_num, WSMWinEntry *win_entry)

{

    int size;

    size  = sizeof(CARD32);

    size += sizeof(CARD32) * win_entry->num_windows;

    size  = sizeof(CARD32);

    size += sizeof(WindowProperty) * win_entry->num_match_properties;

    return(size);

}

/*	Function Name: WinDataSizePacked

 *	Description: The size that will be taken up with this window data

 *                   once it is packed into the protocol stream.

 *	Arguments: dpy, screen_num - The screen nmuber and display that

 *                                   we are talking to.

 *                 win_data - The data stored in a window data structure list.

 *                 num - number of items in the list.

 *                 fmt - The type of format to use to pack this data.

 *	Returns: The size.

 */

static int 

WinDataSizePacked(Display *dpy, int screen_num, 

		  WSMWinData *win_data, int num, WSMConfigFormatType fmt)

{

    register int i, size;

    WSMConfigFormatData *fmt_data = _WSMGetConfigFormat(dpy, screen_num, fmt);

    size = fmt_data->num_attrs / 8 + 1;	/* Size of header bits. */

    for ( i = 0; i < num; i++, win_data++) {

	WSMAttribute *attr = _WSMGetMatchingAttr(win_data->nameq, fmt_data);

	if (attr == NULL) {

	    /*

	     * ||| ERROR.

	     */

	    continue;

	}

	switch(win_data->type) {

	case WSM_VALUE_DATA:

	    size += attr->size/8;

	    break;

	default:		/* All others are lists. */

	    size += COUNT_SIZE;

	    size += ((attr->size/8) * win_data->data_len);

	    break;

	}

    }

    return(size);

}

/************************************************************

 *

 *  Internal Routines for packing data into the protocol stream.

 *

 ************************************************************/

/*	Function Name: PackString

 *	Description: Packs a string into the data stream.

 *	Arguments: data - The data stream to pack into.

 *                 str - The string to pack.

 *	Returns: data - A pointer into the next empty location in the

 *                      data stream.

 */

MessageData

PackString(MessageData data, String str)

{

    register int i, len = strlen(str);

    data = PackListNum(data, len);

    for (i = 0; i < len; i++, str++) 

	data = PackCARD8(data, *str);

    return(data);

}

/*	Function Name: PackConfigFormat

 *	Description: Packs the configuration format into the data stream.

 *	Arguments: data - the datastream.

 *                 config - the reply config format message.

 *	Returns: data - A pointer into the next empty location in the

 *                      data stream.

 */

static MessageData 

PackConfigFormat(MessageData data, WSMConfigFormatReply *config)

{

    data = PackBoolean(data, config->accepts_diffs);

    data = PackSingleAttribute(data, config->global_formats,

			       config->num_global_formats);

    data = PackSingleAttribute(data, config->window_formats,

			       config->num_window_formats);

    data = PackSingleAttribute(data, config->icon_formats,

			       config->num_icon_formats);