diff options
Diffstat (limited to 'depends/libxcb/depends/libxdmcp')
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Array.c | 260 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Fill.c | 68 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Flush.c | 53 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Key.c | 140 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Read.c | 244 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Unwrap.c | 90 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Wrap.c | 128 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Wrap.h | 15 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Wraphelp.c | 495 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/Write.c | 151 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/config.h | 188 | ||||
| -rw-r--r-- | depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h | 181 |
12 files changed, 2013 insertions, 0 deletions
diff --git a/depends/libxcb/depends/libxdmcp/Array.c b/depends/libxcb/depends/libxdmcp/Array.c new file mode 100644 index 0000000..b7bcc48 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Array.c @@ -0,0 +1,260 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> +#include <stdint.h> +#include <stdlib.h> + +/* + * This variant of malloc does not return NULL if zero size is passed into. + */ +static void * +xmalloc(size_t size) +{ + return malloc(size ? size : 1); +} + +/* + * This variant of calloc does not return NULL if zero count is passed into. + */ +static void * +xcalloc(size_t n, size_t size) +{ + return calloc(n ? n : 1, size); +} + +/* + * This variant of realloc does not return NULL if zero size is passed into + */ +static void * +xrealloc(void *ptr, size_t size) +{ + return realloc(ptr, size ? size : 1); +} + +int +XdmcpAllocARRAY8 (ARRAY8Ptr array, int length) +{ + /* length defined in ARRAY8 struct is a CARD16 (not CARD8 like the rest) */ + if ((length > UINT16_MAX) || (length < 0)) + array->data = NULL; + else + array->data = xmalloc(length * sizeof (CARD8)); + + if (array->data == NULL) { + array->length = 0; + return FALSE; + } + array->length = (CARD16) length; + return TRUE; +} + +int +XdmcpAllocARRAY16 (ARRAY16Ptr array, int length) +{ + /* length defined in ARRAY16 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + array->data = NULL; + else + array->data = xmalloc(length * sizeof (CARD16)); + + if (array->data == NULL) { + array->length = 0; + return FALSE; + } + array->length = (CARD8) length; + return TRUE; +} + +int +XdmcpAllocARRAY32 (ARRAY32Ptr array, int length) +{ + /* length defined in ARRAY32 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + array->data = NULL; + else + array->data = xmalloc(length * sizeof (CARD32)); + + if (array->data == NULL) { + array->length = 0; + return FALSE; + } + array->length = (CARD8) length; + return TRUE; +} + +int +XdmcpAllocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length) +{ + /* length defined in ARRAYofARRAY8 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + array->data = NULL; + else + /* + * Use calloc to ensure the pointers are cleared out so we + * don't try to free garbage if XdmcpDisposeARRAYofARRAY8() + * is called before the caller sets them to valid pointers. + */ + array->data = xcalloc(length, sizeof (ARRAY8)); + + if (array->data == NULL) { + array->length = 0; + return FALSE; + } + array->length = (CARD8) length; + return TRUE; +} + +int +XdmcpARRAY8Equal (const ARRAY8Ptr array1, const ARRAY8Ptr array2) +{ + if (array1->length != array2->length) + return FALSE; + if (memcmp(array1->data, array2->data, array1->length) != 0) + return FALSE; + return TRUE; +} + +int +XdmcpCopyARRAY8 (const ARRAY8Ptr src, ARRAY8Ptr dst) +{ + if (!XdmcpAllocARRAY8(dst, src->length)) + return FALSE; + memcpy(dst->data, src->data, src->length * sizeof (CARD8)); + return TRUE; +} + +int +XdmcpReallocARRAY8 (ARRAY8Ptr array, int length) +{ + CARD8Ptr newData; + + /* length defined in ARRAY8 struct is a CARD16 (not CARD8 like the rest) */ + if ((length > UINT16_MAX) || (length < 0)) + return FALSE; + + newData = (CARD8Ptr) xrealloc(array->data, length * sizeof (CARD8)); + if (!newData) + return FALSE; + array->length = (CARD16) length; + array->data = newData; + return TRUE; +} + +int +XdmcpReallocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length) +{ + ARRAY8Ptr newData; + + /* length defined in ARRAYofARRAY8 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + return FALSE; + + newData = (ARRAY8Ptr) xrealloc(array->data, length * sizeof (ARRAY8)); + if (!newData) + return FALSE; + if (length > array->length) + memset(newData + array->length, 0, + (length - array->length) * sizeof (ARRAY8)); + array->length = (CARD8) length; + array->data = newData; + return TRUE; +} + +int +XdmcpReallocARRAY16 (ARRAY16Ptr array, int length) +{ + CARD16Ptr newData; + + /* length defined in ARRAY16 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + return FALSE; + newData = (CARD16Ptr) xrealloc(array->data, length * sizeof (CARD16)); + if (!newData) + return FALSE; + array->length = (CARD8) length; + array->data = newData; + return TRUE; +} + +int +XdmcpReallocARRAY32 (ARRAY32Ptr array, int length) +{ + CARD32Ptr newData; + + /* length defined in ARRAY32 struct is a CARD8 */ + if ((length > UINT8_MAX) || (length < 0)) + return FALSE; + + newData = (CARD32Ptr) xrealloc(array->data, length * sizeof (CARD32)); + if (!newData) + return FALSE; + array->length = (CARD8) length; + array->data = newData; + return TRUE; +} + +void +XdmcpDisposeARRAY8 (ARRAY8Ptr array) +{ + free(array->data); + array->length = 0; + array->data = NULL; +} + +void +XdmcpDisposeARRAY16 (ARRAY16Ptr array) +{ + free(array->data); + array->length = 0; + array->data = NULL; +} + +void +XdmcpDisposeARRAY32 (ARRAY32Ptr array) +{ + free(array->data); + array->length = 0; + array->data = NULL; +} + +void +XdmcpDisposeARRAYofARRAY8 (ARRAYofARRAY8Ptr array) +{ + if (array->data != NULL) { + for (unsigned int i = 0; i < (unsigned int) array->length; i++) + XdmcpDisposeARRAY8 (&array->data[i]); + free(array->data); + } + array->length = 0; + array->data = NULL; +} diff --git a/depends/libxcb/depends/libxdmcp/Fill.c b/depends/libxcb/depends/libxdmcp/Fill.c new file mode 100644 index 0000000..61cd974 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Fill.c @@ -0,0 +1,68 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef WIN32 +#define _WILLWINSOCK_ +#endif +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> +#include <stdlib.h> + +#ifdef WIN32 +#include <X11/Xwinsock.h> +#else +#include <sys/socket.h> +#endif + +int +XdmcpFill (int fd, XdmcpBufferPtr buffer, XdmcpNetaddr from, int *fromlen) +{ + BYTE *newBuf; + + if (buffer->size < XDM_MAX_MSGLEN) + { + newBuf = (BYTE *) malloc(XDM_MAX_MSGLEN); + if (newBuf) + { + free(buffer->data); + buffer->data = newBuf; + buffer->size = XDM_MAX_MSGLEN; + } + } + buffer->pointer = 0; + buffer->count = recvfrom (fd, (char*)buffer->data, buffer->size, 0, + (struct sockaddr *)from, (void *)fromlen); + if (buffer->count < 6) { + buffer->count = 0; + return FALSE; + } + return TRUE; +} diff --git a/depends/libxcb/depends/libxdmcp/Flush.c b/depends/libxcb/depends/libxdmcp/Flush.c new file mode 100644 index 0000000..1654846 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Flush.c @@ -0,0 +1,53 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef WIN32 +#define _WILLWINSOCK_ +#endif +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> + +#ifdef WIN32 +#include <X11/Xwinsock.h> +#else +#include <sys/socket.h> +#endif + +int +XdmcpFlush (int fd, XdmcpBufferPtr buffer, XdmcpNetaddr to, int tolen) +{ + int result; + result = sendto (fd, (char *)buffer->data, buffer->pointer, 0, + (struct sockaddr *)to, tolen); + if (result != buffer->pointer) + return FALSE; + return TRUE; +} diff --git a/depends/libxcb/depends/libxdmcp/Key.c b/depends/libxcb/depends/libxdmcp/Key.c new file mode 100644 index 0000000..e430eb0 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Key.c @@ -0,0 +1,140 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> + +#ifdef __MUSL__ +#ifdef HAVE_ARC4RANDOM_BUF +#undef HAVE_ARC4RANDOM_BUF +#endif /* HAVE_ARC4RANDOM_BUF */ +#endif /* __MUSL__ */ + +#ifndef HAVE_ARC4RANDOM_BUF +static void +getbits (long data, unsigned char *dst) +{ + dst[0] = (data ) & 0xff; + dst[1] = (data >> 8) & 0xff; + dst[2] = (data >> 16) & 0xff; + dst[3] = (data >> 24) & 0xff; +} +#endif + +#define Time_t time_t + +#include <stdlib.h> + +#if defined(HAVE_LRAND48) && defined(HAVE_SRAND48) +#define srandom srand48 +#define random lrand48 +#endif +#ifdef WIN32 +#include <process.h> +#define srandom srand +#define random rand +#define getpid(x) _getpid(x) +#endif + +#ifndef HAVE_ARC4RANDOM_BUF + +/* Solaris 11.3.0 - 11.4.15 only define getentropy() in <sys/random.h> */ +#if HAVE_GETENTROPY && HAVE_SYS_RANDOM_H +# include <sys/random.h> +#endif + +static void +insecure_getrandom_buf (unsigned char *auth, int len) +{ + long lowbits, highbits; + + srandom ((int)getpid() ^ time((Time_t *)0)); + lowbits = random (); + highbits = random (); + getbits (lowbits, auth); + getbits (highbits, auth + 4); +} + +static void +arc4random_buf (void *auth, int len) +{ +#if HAVE_GETENTROPY + int ret; + + /* weak emulation of arc4random through the getentropy libc call */ + ret = getentropy (auth, len); + if (ret == 0) + return; +#endif /* HAVE_GETENTROPY */ + + insecure_getrandom_buf (auth, len); +} + +#endif /* !defined(HAVE_ARC4RANDOM_BUF) */ + +void +XdmcpGenerateKey (XdmAuthKeyPtr key) +{ + arc4random_buf(key->data, 8); +} + +int +XdmcpCompareKeys (const XdmAuthKeyPtr a, const XdmAuthKeyPtr b) +{ + int i; + + for (i = 0; i < 8; i++) + if (a->data[i] != b->data[i]) + return FALSE; + return TRUE; +} + +void +XdmcpIncrementKey (XdmAuthKeyPtr key) +{ + int i; + + i = 7; + while (++key->data[i] == 0) + if (--i < 0) + break; +} + +void +XdmcpDecrementKey (XdmAuthKeyPtr key) +{ + int i; + + i = 7; + while (key->data[i]-- == 0) + if (--i < 0) + break; +} diff --git a/depends/libxcb/depends/libxdmcp/Read.c b/depends/libxcb/depends/libxdmcp/Read.c new file mode 100644 index 0000000..7da6163 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Read.c @@ -0,0 +1,244 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> +#include <stdlib.h> + +int +XdmcpReadHeader (XdmcpBufferPtr buffer, XdmcpHeaderPtr header) +{ + if (XdmcpReadCARD16 (buffer, &header->version) && + XdmcpReadCARD16 (buffer, &header->opcode) && + XdmcpReadCARD16 (buffer, &header->length)) + return TRUE; + return FALSE; +} + +int +XdmcpReadRemaining (const XdmcpBufferPtr buffer) +{ + return buffer->count - buffer->pointer; +} + +int +XdmcpReadARRAY8 (XdmcpBufferPtr buffer, ARRAY8Ptr array) +{ + int i; + + /* + * When returning FALSE, guarantee that array->data = 0. + * This allows the user to safely call XdmcpDisposeARRAY8(array) + * regardless of the return value below. + * Note that XdmcpDisposeARRAY*(array) will call free(array->data), + * so we must guarantee that array->data is NULL or a malloced pointer. + */ + if (!XdmcpReadCARD16 (buffer, &array->length)) { + array->data = NULL; + return FALSE; + } + if (!array->length) + { + array->data = NULL; + return TRUE; + } + array->data = (CARD8 *) malloc(array->length * sizeof (CARD8)); + if (!array->data) + return FALSE; + for (i = 0; i < (int)array->length; i++) + { + if (!XdmcpReadCARD8 (buffer, &array->data[i])) + { + free(array->data); + array->data = NULL; + array->length = 0; + return FALSE; + } + } + return TRUE; +} + +int +XdmcpReadARRAY16 (XdmcpBufferPtr buffer, ARRAY16Ptr array) +{ + int i; + + /* + * When returning FALSE, guarantee that array->data = 0. + * This allows the user to safely call XdmcpDisposeARRAY16(array) + * regardless of the return value below. + * Note that XdmcpDisposeARRAY*(array) will call free(array->data), + * so we must guarantee that array->data is NULL or a malloced pointer. + */ + if (!XdmcpReadCARD8 (buffer, &array->length)) { + array->data = NULL; + return FALSE; + } + if (!array->length) + { + array->data = NULL; + return TRUE; + } + array->data = (CARD16 *) malloc(array->length * sizeof (CARD16)); + if (!array->data) + return FALSE; + for (i = 0; i < (int)array->length; i++) + { + if (!XdmcpReadCARD16 (buffer, &array->data[i])) + { + free(array->data); + array->data = NULL; + array->length = 0; + return FALSE; + } + } + return TRUE; +} + +int +XdmcpReadARRAY32 (XdmcpBufferPtr buffer, ARRAY32Ptr array) +{ + int i; + + /* + * When returning FALSE, guarantee that array->data = 0. + * This allows the user to safely call XdmcpDisposeARRAY32(array) + * regardless of the return value below. + * Note that XdmcpDisposeARRAY*(array) will call free(array->data), + * so we must guarantee that array->data is NULL or a malloced pointer. + */ + if (!XdmcpReadCARD8 (buffer, &array->length)) { + array->data = NULL; + return FALSE; + } + if (!array->length) + { + array->data = NULL; + return TRUE; + } + array->data = (CARD32 *) malloc(array->length * sizeof (CARD32)); + if (!array->data) + return FALSE; + for (i = 0; i < (int)array->length; i++) + { + if (!XdmcpReadCARD32 (buffer, &array->data[i])) + { + free(array->data); + array->data = NULL; + array->length = 0; + return FALSE; + } + } + return TRUE; +} + +int +XdmcpReadARRAYofARRAY8 (XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array) +{ + CARD8 i; + + /* + * When returning FALSE, guarantee that array->data = 0. + * This allows the user to safely call XdmcpDisposeARRAYofARRAY8(array) + * regardless of the return value below. + * Note that XdmcpDisposeARRAY*(array) will call free(array->data), + * so we must guarantee that array->data is NULL or a malloced pointer. + */ + if (!XdmcpReadCARD8 (buffer, &array->length)) { + array->data = NULL; + return FALSE; + } + if (!array->length) + { + array->data = NULL; + return TRUE; + } + array->data = (ARRAY8 *) malloc(array->length * sizeof (ARRAY8)); + if (!array->data) + return FALSE; + for (i = 0; i < array->length; i++) + { + if (!XdmcpReadARRAY8 (buffer, &array->data[i])) + { + /* + * We must free all of the arrays allocated thus far in the loop + * and free array->data and finally set array->data = 0; + * The easiest way to do this is to reset the length and call + * XdmcpDisposeARRAYofARRAY8(array). + */ + array->length = i; + XdmcpDisposeARRAYofARRAY8(array); + return FALSE; + } + } + return TRUE; +} + +int +XdmcpReadCARD8 (XdmcpBufferPtr buffer, CARD8Ptr valuep) +{ + if (buffer->pointer >= buffer->count) + return FALSE; + *valuep = (CARD8) buffer->data[buffer->pointer++]; + return TRUE; +} + +int +XdmcpReadCARD16 (XdmcpBufferPtr buffer, CARD16Ptr valuep) +{ + CARD8 high, low; + + if (XdmcpReadCARD8 (buffer, &high) && + XdmcpReadCARD8 (buffer, &low)) + { + *valuep = (((CARD16) high) << 8) | ((CARD16) low); + return TRUE; + } + return FALSE; +} + +int +XdmcpReadCARD32 (XdmcpBufferPtr buffer, CARD32Ptr valuep) +{ + CARD8 byte0, byte1, byte2, byte3; + if (XdmcpReadCARD8 (buffer, &byte0) && + XdmcpReadCARD8 (buffer, &byte1) && + XdmcpReadCARD8 (buffer, &byte2) && + XdmcpReadCARD8 (buffer, &byte3)) + { + *valuep = (((CARD32) byte0) << 24) | + (((CARD32) byte1) << 16) | + (((CARD32) byte2) << 8) | + (((CARD32) byte3)); + return TRUE; + } + return FALSE; +} diff --git a/depends/libxcb/depends/libxdmcp/Unwrap.c b/depends/libxcb/depends/libxdmcp/Unwrap.c new file mode 100644 index 0000000..82a10ee --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Unwrap.c @@ -0,0 +1,90 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> + +#ifdef HASXDMAUTH + +/* + * The following function exists only to demonstrate the + * desired functional interface for this routine. You will + * need to add the appropriate algorithm if you wish to + * use XDM-AUTHENTICATION-1/XDM-AUTHORIZATION-1. + * + * The interface for this routine is quite simple. All three + * arguments are arrays of 8 unsigned characters, the first two + * are 64 bits of useful data, the last is 56 bits of useful + * data packed into 8 bytes, using the low 7 bits of each + * byte, filling the high bit with odd parity. + * + * Examine the XDMCP specification for the correct algorithm + */ + +#include "Wrap.h" + +void +XdmcpUnwrap ( + unsigned char *input, + unsigned char *wrapper, + unsigned char *output, + int bytes) +{ + int i, j, k; + unsigned char tmp[8]; + unsigned char blocks[2][8]; + unsigned char expand_wrapper[8]; + auth_wrapper_schedule schedule; + + _XdmcpWrapperToOddParity (wrapper, expand_wrapper); + _XdmcpAuthSetup (expand_wrapper, schedule); + + k = 0; + for (j = 0; j < bytes; j += 8) + { + if (bytes - j < 8) + return; /* bad input length */ + for (i = 0; i < 8; i++) + blocks[k][i] = input[j + i]; + _XdmcpAuthDoIt ((unsigned char *) (input + j), (unsigned char *) tmp, schedule, 0); + /* block chaining */ + k = (k == 0) ? 1 : 0; + for (i = 0; i < 8; i++) + { + if (j == 0) + output[j + i] = tmp[i]; + else + output[j + i] = tmp[i] ^ blocks[k][i]; + } + } +} + +#endif /* HASXDMAUTH */ diff --git a/depends/libxcb/depends/libxdmcp/Wrap.c b/depends/libxcb/depends/libxdmcp/Wrap.c new file mode 100644 index 0000000..f025caf --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Wrap.c @@ -0,0 +1,128 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> + +#ifdef HASXDMAUTH + +/* + * The following function exists only to demonstrate the + * desired functional interface for this routine. You will + * need to add the appropriate algorithm if you wish to + * use XDM-AUTHENTICATION-1/XDM-AUTHORIZATION-1. + * + * Examine the XDMCP specification for the correct algorithm + */ + +#include "Wrap.h" + +void +XdmcpWrap ( + unsigned char *input, + unsigned char *wrapper, + unsigned char *output, + int bytes) +{ + int i, j; + int len; + unsigned char tmp[8]; + unsigned char expand_wrapper[8]; + auth_wrapper_schedule schedule; + + _XdmcpWrapperToOddParity (wrapper, expand_wrapper); + _XdmcpAuthSetup (expand_wrapper, schedule); + for (j = 0; j < bytes; j += 8) + { + len = 8; + if (bytes - j < len) + len = bytes - j; + /* block chaining */ + for (i = 0; i < len; i++) + { + if (j == 0) + tmp[i] = input[i]; + else + tmp[i] = input[j + i] ^ output[j - 8 + i]; + } + for (; i < 8; i++) + { + if (j == 0) + tmp[i] = 0; + else + tmp[i] = 0 ^ output[j - 8 + i]; + } + _XdmcpAuthDoIt (tmp, (output + j), schedule, 1); + } +} + +/* + * Given a 56 bit wrapper in XDMCP format, create a 56 + * bit wrapper in 7-bits + odd parity format + */ + +static int +OddParity (unsigned char c) +{ + c = c ^ (c >> 4); + c = c ^ (c >> 2); + c = c ^ (c >> 1); + return ~c & 0x1; +} + +/* + * Spread the 56 bit wrapper among 8 bytes, using the upper 7 bits + * of each byte, and storing an odd parity bit in the low bit + */ + +void +_XdmcpWrapperToOddParity ( + unsigned char *in, + unsigned char *out) +{ + int ashift, bshift; + int i; + unsigned char c; + + ashift = 7; + bshift = 1; + for (i = 0; i < 7; i++) + { + c = ((in[i] << ashift) | (in[i+1] >> bshift)) & 0x7f; + out[i] = (c << 1) | OddParity (c); + ashift--; + bshift++; + } + c = in[i]; + out[i] = (c << 1) | OddParity(c); +} + +#endif diff --git a/depends/libxcb/depends/libxdmcp/Wrap.h b/depends/libxcb/depends/libxdmcp/Wrap.h new file mode 100644 index 0000000..479da5f --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Wrap.h @@ -0,0 +1,15 @@ +/* + * header file for compatibility with something useful + */ + +typedef unsigned char auth_cblock[8]; /* block size */ + +typedef struct auth_ks_struct { auth_cblock _; } auth_wrapper_schedule[16]; + +extern void _XdmcpWrapperToOddParity (unsigned char *in, unsigned char *out); + +#ifdef HASXDMAUTH +extern void _XdmcpAuthSetup (auth_cblock key, auth_wrapper_schedule schedule); +extern void _XdmcpAuthDoIt (auth_cblock input, auth_cblock output, + auth_wrapper_schedule schedule, int edflag); +#endif diff --git a/depends/libxcb/depends/libxdmcp/Wraphelp.c b/depends/libxcb/depends/libxdmcp/Wraphelp.c new file mode 100644 index 0000000..e7b33ec --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Wraphelp.c @@ -0,0 +1,495 @@ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <sys/types.h> +#include <X11/Xmd.h> +#include "Wrap.h" + +/* des routines for non-usa - eay 10/9/1991 eay@psych.psy.uq.oz.au + * These routines were written for speed not size so they are bigger than + * needed. I have removed some of the loop unrolling, this will reduce + * code size at the expense of some speed. + * 25/9/1991 eay - much faster _XdmcpAuthSetup (4 times faster). + * 19/9/1991 eay - cleaned up the IP and FP code. + * 10/9/1991 eay - first release. + * The des routines this file has been made from can be found in + * ftp.psy.uq.oz.au /pub/DES + * This particular version derived from OpenBSD Revision 1.3. + */ + +/* + * + * Export Requirements. + * You may not export or re-export this software or any copy or + * adaptation in violation of any applicable laws or regulations. + * + * Without limiting the generality of the foregoing, hardware, software, + * technology or services provided under this license agreement may not + * be exported, reexported, transferred or downloaded to or within (or to + * a national resident of) countries under U.S. economic embargo + * including the following countries: + * + * Cuba, Iran, Libya, North Korea, Sudan and Syria. This list is subject + * to change. + * + * Hardware, software, technology or services may not be exported, + * reexported, transferred or downloaded to persons or entities listed on + * the U.S. Department of Commerce Denied Persons List, Entity List of + * proliferation concern or on any U.S. Treasury Department Designated + * Nationals exclusion list, or to parties directly or indirectly + * involved in the development or production of nuclear, chemical, + * biological weapons or in missile technology programs as specified in + * the U.S. Export Administration Regulations (15 CFR 744). + * + * By accepting this license agreement you confirm that you are not + * located in (or a national resident of) any country under U.S. economic + * embargo, not identified on any U.S. Department of Commerce Denied + * Persons List, Entity List or Treasury Department Designated Nationals + * exclusion list, and not directly or indirectly involved in the + * development or production of nuclear, chemical, biological weapons or + * in missile technology programs as specified in the U.S. Export + * Administration Regulations. + * + * + * Local Country Import Requirements. The software you are about to + * download contains cryptography technology. Some countries regulate the + * import, use and/or export of certain products with cryptography. The + * X.org Foundation makes no claims as to the applicability of local + * country import, use and/or export regulations in relation to the + * download of this product. If you are located outside the U.S. and + * Canada you are advised to consult your local country regulations to + * insure compliance. + */ + +static const CARD32 skb[8][64] = { + /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ + { 0x00000000,0x00000010,0x20000000,0x20000010, + 0x00010000,0x00010010,0x20010000,0x20010010, + 0x00000800,0x00000810,0x20000800,0x20000810, + 0x00010800,0x00010810,0x20010800,0x20010810, + 0x00000020,0x00000030,0x20000020,0x20000030, + 0x00010020,0x00010030,0x20010020,0x20010030, + 0x00000820,0x00000830,0x20000820,0x20000830, + 0x00010820,0x00010830,0x20010820,0x20010830, + 0x00080000,0x00080010,0x20080000,0x20080010, + 0x00090000,0x00090010,0x20090000,0x20090010, + 0x00080800,0x00080810,0x20080800,0x20080810, + 0x00090800,0x00090810,0x20090800,0x20090810, + 0x00080020,0x00080030,0x20080020,0x20080030, + 0x00090020,0x00090030,0x20090020,0x20090030, + 0x00080820,0x00080830,0x20080820,0x20080830, + 0x00090820,0x00090830,0x20090820,0x20090830 }, + /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */ + { 0x00000000,0x02000000,0x00002000,0x02002000, + 0x00200000,0x02200000,0x00202000,0x02202000, + 0x00000004,0x02000004,0x00002004,0x02002004, + 0x00200004,0x02200004,0x00202004,0x02202004, + 0x00000400,0x02000400,0x00002400,0x02002400, + 0x00200400,0x02200400,0x00202400,0x02202400, + 0x00000404,0x02000404,0x00002404,0x02002404, + 0x00200404,0x02200404,0x00202404,0x02202404, + 0x10000000,0x12000000,0x10002000,0x12002000, + 0x10200000,0x12200000,0x10202000,0x12202000, + 0x10000004,0x12000004,0x10002004,0x12002004, + 0x10200004,0x12200004,0x10202004,0x12202004, + 0x10000400,0x12000400,0x10002400,0x12002400, + 0x10200400,0x12200400,0x10202400,0x12202400, + 0x10000404,0x12000404,0x10002404,0x12002404, + 0x10200404,0x12200404,0x10202404,0x12202404 }, + /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */ + { 0x00000000,0x00000001,0x00040000,0x00040001, + 0x01000000,0x01000001,0x01040000,0x01040001, + 0x00000002,0x00000003,0x00040002,0x00040003, + 0x01000002,0x01000003,0x01040002,0x01040003, + 0x00000200,0x00000201,0x00040200,0x00040201, + 0x01000200,0x01000201,0x01040200,0x01040201, + 0x00000202,0x00000203,0x00040202,0x00040203, + 0x01000202,0x01000203,0x01040202,0x01040203, + 0x08000000,0x08000001,0x08040000,0x08040001, + 0x09000000,0x09000001,0x09040000,0x09040001, + 0x08000002,0x08000003,0x08040002,0x08040003, + 0x09000002,0x09000003,0x09040002,0x09040003, + 0x08000200,0x08000201,0x08040200,0x08040201, + 0x09000200,0x09000201,0x09040200,0x09040201, + 0x08000202,0x08000203,0x08040202,0x08040203, + 0x09000202,0x09000203,0x09040202,0x09040203 }, + /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */ + { 0x00000000,0x00100000,0x00000100,0x00100100, + 0x00000008,0x00100008,0x00000108,0x00100108, + 0x00001000,0x00101000,0x00001100,0x00101100, + 0x00001008,0x00101008,0x00001108,0x00101108, + 0x04000000,0x04100000,0x04000100,0x04100100, + 0x04000008,0x04100008,0x04000108,0x04100108, + 0x04001000,0x04101000,0x04001100,0x04101100, + 0x04001008,0x04101008,0x04001108,0x04101108, + 0x00020000,0x00120000,0x00020100,0x00120100, + 0x00020008,0x00120008,0x00020108,0x00120108, + 0x00021000,0x00121000,0x00021100,0x00121100, + 0x00021008,0x00121008,0x00021108,0x00121108, + 0x04020000,0x04120000,0x04020100,0x04120100, + 0x04020008,0x04120008,0x04020108,0x04120108, + 0x04021000,0x04121000,0x04021100,0x04121100, + 0x04021008,0x04121008,0x04021108,0x04121108 }, + /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ + { 0x00000000,0x10000000,0x00010000,0x10010000, + 0x00000004,0x10000004,0x00010004,0x10010004, + 0x20000000,0x30000000,0x20010000,0x30010000, + 0x20000004,0x30000004,0x20010004,0x30010004, + 0x00100000,0x10100000,0x00110000,0x10110000, + 0x00100004,0x10100004,0x00110004,0x10110004, + 0x20100000,0x30100000,0x20110000,0x30110000, + 0x20100004,0x30100004,0x20110004,0x30110004, + 0x00001000,0x10001000,0x00011000,0x10011000, + 0x00001004,0x10001004,0x00011004,0x10011004, + 0x20001000,0x30001000,0x20011000,0x30011000, + 0x20001004,0x30001004,0x20011004,0x30011004, + 0x00101000,0x10101000,0x00111000,0x10111000, + 0x00101004,0x10101004,0x00111004,0x10111004, + 0x20101000,0x30101000,0x20111000,0x30111000, + 0x20101004,0x30101004,0x20111004,0x30111004 }, + /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */ + { 0x00000000,0x08000000,0x00000008,0x08000008, + 0x00000400,0x08000400,0x00000408,0x08000408, + 0x00020000,0x08020000,0x00020008,0x08020008, + 0x00020400,0x08020400,0x00020408,0x08020408, + 0x00000001,0x08000001,0x00000009,0x08000009, + 0x00000401,0x08000401,0x00000409,0x08000409, + 0x00020001,0x08020001,0x00020009,0x08020009, + 0x00020401,0x08020401,0x00020409,0x08020409, + 0x02000000,0x0A000000,0x02000008,0x0A000008, + 0x02000400,0x0A000400,0x02000408,0x0A000408, + 0x02020000,0x0A020000,0x02020008,0x0A020008, + 0x02020400,0x0A020400,0x02020408,0x0A020408, + 0x02000001,0x0A000001,0x02000009,0x0A000009, + 0x02000401,0x0A000401,0x02000409,0x0A000409, + 0x02020001,0x0A020001,0x02020009,0x0A020009, + 0x02020401,0x0A020401,0x02020409,0x0A020409 }, + /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */ + { 0x00000000,0x00000100,0x00080000,0x00080100, + 0x01000000,0x01000100,0x01080000,0x01080100, + 0x00000010,0x00000110,0x00080010,0x00080110, + 0x01000010,0x01000110,0x01080010,0x01080110, + 0x00200000,0x00200100,0x00280000,0x00280100, + 0x01200000,0x01200100,0x01280000,0x01280100, + 0x00200010,0x00200110,0x00280010,0x00280110, + 0x01200010,0x01200110,0x01280010,0x01280110, + 0x00000200,0x00000300,0x00080200,0x00080300, + 0x01000200,0x01000300,0x01080200,0x01080300, + 0x00000210,0x00000310,0x00080210,0x00080310, + 0x01000210,0x01000310,0x01080210,0x01080310, + 0x00200200,0x00200300,0x00280200,0x00280300, + 0x01200200,0x01200300,0x01280200,0x01280300, + 0x00200210,0x00200310,0x00280210,0x00280310, + 0x01200210,0x01200310,0x01280210,0x01280310 }, + /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */ + { 0x00000000,0x04000000,0x00040000,0x04040000, + 0x00000002,0x04000002,0x00040002,0x04040002, + 0x00002000,0x04002000,0x00042000,0x04042000, + 0x00002002,0x04002002,0x00042002,0x04042002, + 0x00000020,0x04000020,0x00040020,0x04040020, + 0x00000022,0x04000022,0x00040022,0x04040022, + 0x00002020,0x04002020,0x00042020,0x04042020, + 0x00002022,0x04002022,0x00042022,0x04042022, + 0x00000800,0x04000800,0x00040800,0x04040800, + 0x00000802,0x04000802,0x00040802,0x04040802, + 0x00002800,0x04002800,0x00042800,0x04042800, + 0x00002802,0x04002802,0x00042802,0x04042802, + 0x00000820,0x04000820,0x00040820,0x04040820, + 0x00000822,0x04000822,0x00040822,0x04040822, + 0x00002820,0x04002820,0x00042820,0x04042820, + 0x00002822,0x04002822,0x00042822,0x04042822 } +}; + + +static const CARD32 SPtrans[8][64] = { + /* nibble 0 */ + { 0x00410100, 0x00010000, 0x40400000, 0x40410100, + 0x00400000, 0x40010100, 0x40010000, 0x40400000, + 0x40010100, 0x00410100, 0x00410000, 0x40000100, + 0x40400100, 0x00400000, 0x00000000, 0x40010000, + 0x00010000, 0x40000000, 0x00400100, 0x00010100, + 0x40410100, 0x00410000, 0x40000100, 0x00400100, + 0x40000000, 0x00000100, 0x00010100, 0x40410000, + 0x00000100, 0x40400100, 0x40410000, 0x00000000, + 0x00000000, 0x40410100, 0x00400100, 0x40010000, + 0x00410100, 0x00010000, 0x40000100, 0x00400100, + 0x40410000, 0x00000100, 0x00010100, 0x40400000, + 0x40010100, 0x40000000, 0x40400000, 0x00410000, + 0x40410100, 0x00010100, 0x00410000, 0x40400100, + 0x00400000, 0x40000100, 0x40010000, 0x00000000, + 0x00010000, 0x00400000, 0x40400100, 0x00410100, + 0x40000000, 0x40410000, 0x00000100, 0x40010100 }, + + /* nibble 1 */ + { 0x08021002, 0x00000000, 0x00021000, 0x08020000, + 0x08000002, 0x00001002, 0x08001000, 0x00021000, + 0x00001000, 0x08020002, 0x00000002, 0x08001000, + 0x00020002, 0x08021000, 0x08020000, 0x00000002, + 0x00020000, 0x08001002, 0x08020002, 0x00001000, + 0x00021002, 0x08000000, 0x00000000, 0x00020002, + 0x08001002, 0x00021002, 0x08021000, 0x08000002, + 0x08000000, 0x00020000, 0x00001002, 0x08021002, + 0x00020002, 0x08021000, 0x08001000, 0x00021002, + 0x08021002, 0x00020002, 0x08000002, 0x00000000, + 0x08000000, 0x00001002, 0x00020000, 0x08020002, + 0x00001000, 0x08000000, 0x00021002, 0x08001002, + 0x08021000, 0x00001000, 0x00000000, 0x08000002, + 0x00000002, 0x08021002, 0x00021000, 0x08020000, + 0x08020002, 0x00020000, 0x00001002, 0x08001000, + 0x08001002, 0x00000002, 0x08020000, 0x00021000 }, + + /* nibble 2 */ + { 0x20800000, 0x00808020, 0x00000020, 0x20800020, + 0x20008000, 0x00800000, 0x20800020, 0x00008020, + 0x00800020, 0x00008000, 0x00808000, 0x20000000, + 0x20808020, 0x20000020, 0x20000000, 0x20808000, + 0x00000000, 0x20008000, 0x00808020, 0x00000020, + 0x20000020, 0x20808020, 0x00008000, 0x20800000, + 0x20808000, 0x00800020, 0x20008020, 0x00808000, + 0x00008020, 0x00000000, 0x00800000, 0x20008020, + 0x00808020, 0x00000020, 0x20000000, 0x00008000, + 0x20000020, 0x20008000, 0x00808000, 0x20800020, + 0x00000000, 0x00808020, 0x00008020, 0x20808000, + 0x20008000, 0x00800000, 0x20808020, 0x20000000, + 0x20008020, 0x20800000, 0x00800000, 0x20808020, + 0x00008000, 0x00800020, 0x20800020, 0x00008020, + 0x00800020, 0x00000000, 0x20808000, 0x20000020, + 0x20800000, 0x20008020, 0x00000020, 0x00808000 }, + + /* nibble 3 */ + { 0x00080201, 0x02000200, 0x00000001, 0x02080201, + 0x00000000, 0x02080000, 0x02000201, 0x00080001, + 0x02080200, 0x02000001, 0x02000000, 0x00000201, + 0x02000001, 0x00080201, 0x00080000, 0x02000000, + 0x02080001, 0x00080200, 0x00000200, 0x00000001, + 0x00080200, 0x02000201, 0x02080000, 0x00000200, + 0x00000201, 0x00000000, 0x00080001, 0x02080200, + 0x02000200, 0x02080001, 0x02080201, 0x00080000, + 0x02080001, 0x00000201, 0x00080000, 0x02000001, + 0x00080200, 0x02000200, 0x00000001, 0x02080000, + 0x02000201, 0x00000000, 0x00000200, 0x00080001, + 0x00000000, 0x02080001, 0x02080200, 0x00000200, + 0x02000000, 0x02080201, 0x00080201, 0x00080000, + 0x02080201, 0x00000001, 0x02000200, 0x00080201, + 0x00080001, 0x00080200, 0x02080000, 0x02000201, + 0x00000201, 0x02000000, 0x02000001, 0x02080200 }, + + /* nibble 4 */ + { 0x01000000, 0x00002000, 0x00000080, 0x01002084, + 0x01002004, 0x01000080, 0x00002084, 0x01002000, + 0x00002000, 0x00000004, 0x01000004, 0x00002080, + 0x01000084, 0x01002004, 0x01002080, 0x00000000, + 0x00002080, 0x01000000, 0x00002004, 0x00000084, + 0x01000080, 0x00002084, 0x00000000, 0x01000004, + 0x00000004, 0x01000084, 0x01002084, 0x00002004, + 0x01002000, 0x00000080, 0x00000084, 0x01002080, + 0x01002080, 0x01000084, 0x00002004, 0x01002000, + 0x00002000, 0x00000004, 0x01000004, 0x01000080, + 0x01000000, 0x00002080, 0x01002084, 0x00000000, + 0x00002084, 0x01000000, 0x00000080, 0x00002004, + 0x01000084, 0x00000080, 0x00000000, 0x01002084, + 0x01002004, 0x01002080, 0x00000084, 0x00002000, + 0x00002080, 0x01002004, 0x01000080, 0x00000084, + 0x00000004, 0x00002084, 0x01002000, 0x01000004 }, + + /* nibble 5 */ + { 0x10000008, 0x00040008, 0x00000000, 0x10040400, + 0x00040008, 0x00000400, 0x10000408, 0x00040000, + 0x00000408, 0x10040408, 0x00040400, 0x10000000, + 0x10000400, 0x10000008, 0x10040000, 0x00040408, + 0x00040000, 0x10000408, 0x10040008, 0x00000000, + 0x00000400, 0x00000008, 0x10040400, 0x10040008, + 0x10040408, 0x10040000, 0x10000000, 0x00000408, + 0x00000008, 0x00040400, 0x00040408, 0x10000400, + 0x00000408, 0x10000000, 0x10000400, 0x00040408, + 0x10040400, 0x00040008, 0x00000000, 0x10000400, + 0x10000000, 0x00000400, 0x10040008, 0x00040000, + 0x00040008, 0x10040408, 0x00040400, 0x00000008, + 0x10040408, 0x00040400, 0x00040000, 0x10000408, + 0x10000008, 0x10040000, 0x00040408, 0x00000000, + 0x00000400, 0x10000008, 0x10000408, 0x10040400, + 0x10040000, 0x00000408, 0x00000008, 0x10040008 }, + + /* nibble 6 */ + { 0x00000800, 0x00000040, 0x00200040, 0x80200000, + 0x80200840, 0x80000800, 0x00000840, 0x00000000, + 0x00200000, 0x80200040, 0x80000040, 0x00200800, + 0x80000000, 0x00200840, 0x00200800, 0x80000040, + 0x80200040, 0x00000800, 0x80000800, 0x80200840, + 0x00000000, 0x00200040, 0x80200000, 0x00000840, + 0x80200800, 0x80000840, 0x00200840, 0x80000000, + 0x80000840, 0x80200800, 0x00000040, 0x00200000, + 0x80000840, 0x00200800, 0x80200800, 0x80000040, + 0x00000800, 0x00000040, 0x00200000, 0x80200800, + 0x80200040, 0x80000840, 0x00000840, 0x00000000, + 0x00000040, 0x80200000, 0x80000000, 0x00200040, + 0x00000000, 0x80200040, 0x00200040, 0x00000840, + 0x80000040, 0x00000800, 0x80200840, 0x00200000, + 0x00200840, 0x80000000, 0x80000800, 0x80200840, + 0x80200000, 0x00200840, 0x00200800, 0x80000800 }, + + /* nibble 7 */ + { 0x04100010, 0x04104000, 0x00004010, 0x00000000, + 0x04004000, 0x00100010, 0x04100000, 0x04104010, + 0x00000010, 0x04000000, 0x00104000, 0x00004010, + 0x00104010, 0x04004010, 0x04000010, 0x04100000, + 0x00004000, 0x00104010, 0x00100010, 0x04004000, + 0x04104010, 0x04000010, 0x00000000, 0x00104000, + 0x04000000, 0x00100000, 0x04004010, 0x04100010, + 0x00100000, 0x00004000, 0x04104000, 0x00000010, + 0x00100000, 0x00004000, 0x04000010, 0x04104010, + 0x00004010, 0x04000000, 0x00000000, 0x00104000, + 0x04100010, 0x04004010, 0x04004000, 0x00100010, + 0x04104000, 0x00000010, 0x00100010, 0x04004000, + 0x04104010, 0x00100000, 0x04100000, 0x04000010, + 0x00104000, 0x00004010, 0x04004010, 0x04100000, + 0x00000010, 0x04104000, 0x00104010, 0x00000000, + 0x04000000, 0x04100010, 0x00004000, 0x00104010} +}; + +#define ITERATIONS 16 +#define HALF_ITERATIONS 8 + +#define c2l(c,l) (l =((CARD32)(*((c)++))) , \ + l|=((CARD32)(*((c)++)))<< 8, \ + l|=((CARD32)(*((c)++)))<<16, \ + l|=((CARD32)(*((c)++)))<<24) + +#define l2c(l,c) (*((c)++)=(CARD8)(((l) )&0xff), \ + *((c)++)=(CARD8)(((l)>> 8)&0xff), \ + *((c)++)=(CARD8)(((l)>>16)&0xff), \ + *((c)++)=(CARD8)(((l)>>24)&0xff)) + +#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\ + (b)^=(t),\ + (a)^=((t)<<(n))) + +#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\ + (a)=(a)^(t)^(t>>(16-(n))))\ + +static const char shifts2[16] = {0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0}; + +void _XdmcpAuthSetup(auth_cblock key, auth_wrapper_schedule schedule) +{ + CARD32 c,d,t,s; + CARD8 *in; + CARD32 *k; + int i; + + k=(CARD32 *)schedule; + in=(CARD8 *)key; + + c2l(in,c); + c2l(in,d); + + /* do PC1 in 60 simple operations */ + PERM_OP(d,c,t,4,0x0f0f0f0f); + HPERM_OP(c,t,-2, 0xcccc0000); + HPERM_OP(c,t,-1, 0xaaaa0000); + HPERM_OP(c,t, 8, 0x00ff0000); + HPERM_OP(c,t,-1, 0xaaaa0000); + HPERM_OP(d,t,-8, 0xff000000); + HPERM_OP(d,t, 8, 0x00ff0000); + HPERM_OP(d,t, 2, 0x33330000); + d=((d&0x00aa00aa)<<7)|((d&0x55005500)>>7)|(d&0xaa55aa55); + d=(d>>8)|((c&0xf0000000)>>4); + c&=0x0fffffff; + + for (i=0; i<ITERATIONS; i++) { + if (shifts2[i]) { + c=((c>>2)|(c<<26)); d=((d>>2)|(d<<26)); + } else { + c=((c>>1)|(c<<27)); d=((d>>1)|(d<<27)); + } + c&=0x0fffffff; + d&=0x0fffffff; + /* could be a few less shifts but I am to lazy at this + * point in time to investigate */ + s= skb[0][ (c )&0x3f ]| + skb[1][((c>> 6)&0x03)|((c>> 7)&0x3c)]| + skb[2][((c>>13)&0x0f)|((c>>14)&0x30)]| + skb[3][((c>>20)&0x01)|((c>>21)&0x06) | + ((c>>22)&0x38)]; + t= skb[4][ (d )&0x3f ]| + skb[5][((d>> 7)&0x03)|((d>> 8)&0x3c)]| + skb[6][ (d>>15)&0x3f ]| + skb[7][((d>>21)&0x0f)|((d>>22)&0x30)]; + + /* table contained 0213 4657 */ + *(k++)=((t<<16)|(s&0x0000ffff)); + s= ((s>>16)|(t&0xffff0000)); + + s=(s<<4)|(s>>28); + *(k++)=s; + } + return; +} + +#define D_ENCRYPT(L,R,S) \ + t=(R<<1)|(R>>31); \ + u=(t^s[S ]); \ + t=(t^s[S+1]); \ + t=(t>>4)|(t<<28); \ + L^= SPtrans[1][(t )&0x3f]| \ + SPtrans[3][(t>> 8)&0x3f]| \ + SPtrans[5][(t>>16)&0x3f]| \ + SPtrans[7][(t>>24)&0x3f]| \ + SPtrans[0][(u )&0x3f]| \ + SPtrans[2][(u>> 8)&0x3f]| \ + SPtrans[4][(u>>16)&0x3f]| \ + SPtrans[6][(u>>24)&0x3f]; + + +void _XdmcpAuthDoIt(auth_cblock input, auth_cblock output, + auth_wrapper_schedule ks, int encrypt) +{ + CARD32 l,r,t,u; + CARD32 *s; + CARD8 *in,*out; + int i; + + in=(CARD8 *)input; + out=(CARD8 *)output; + c2l(in,l); + c2l(in,r); + + /* do IP */ + PERM_OP(r,l,t, 4,0x0f0f0f0f); + PERM_OP(l,r,t,16,0x0000ffff); + PERM_OP(r,l,t, 2,0x33333333); + PERM_OP(l,r,t, 8,0x00ff00ff); + PERM_OP(r,l,t, 1,0x55555555); + /* r and l are reversed - remember that :-) */ + t=l; + l=r; + r=t; + + s=(CARD32 *)ks; + + if (encrypt) { + for (i=0; i<(ITERATIONS*2); i+=4) { + D_ENCRYPT(l,r, i); /* 1 */ + D_ENCRYPT(r,l, i+2); /* 2 */ + } + } else { + for (i=(ITERATIONS*2)-2; i >= 0; i-=4) { + D_ENCRYPT(l,r, i); /* 1 */ + D_ENCRYPT(r,l, i-2); /* 2 */ + } + } + + /* swap l and r + * we will not do the swap so just remember they are + * reversed for the rest of the subroutine + * luckily by FP fixes this problem :-) */ + + PERM_OP(r,l,t, 1,0x55555555); + PERM_OP(l,r,t, 8,0x00ff00ff); + PERM_OP(r,l,t, 2,0x33333333); + PERM_OP(l,r,t,16,0x0000ffff); + PERM_OP(r,l,t, 4,0x0f0f0f0f); + + l2c(l,out); + l2c(r,out); + return; +} diff --git a/depends/libxcb/depends/libxdmcp/Write.c b/depends/libxcb/depends/libxdmcp/Write.c new file mode 100644 index 0000000..8eb9c50 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/Write.c @@ -0,0 +1,151 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/Xos.h> +#include <X11/X.h> +#include <X11/Xmd.h> +#include <X11/Xdmcp.h> +#include <stdlib.h> + +int +XdmcpWriteHeader ( + XdmcpBufferPtr buffer, + const XdmcpHeaderPtr header) +{ + BYTE *newData; + + if ((int)buffer->size < 6 + (int)header->length) + { + newData = (BYTE *) malloc(XDM_MAX_MSGLEN * sizeof (BYTE)); + if (!newData) + return FALSE; + free((unsigned long *)(buffer->data)); + buffer->data = newData; + buffer->size = XDM_MAX_MSGLEN; + } + buffer->pointer = 0; + if (!XdmcpWriteCARD16 (buffer, header->version)) + return FALSE; + if (!XdmcpWriteCARD16 (buffer, header->opcode)) + return FALSE; + if (!XdmcpWriteCARD16 (buffer, header->length)) + return FALSE; + return TRUE; +} + +int +XdmcpWriteARRAY8 (XdmcpBufferPtr buffer, const ARRAY8Ptr array) +{ + int i; + + if (!XdmcpWriteCARD16 (buffer, array->length)) + return FALSE; + for (i = 0; i < (int)array->length; i++) + if (!XdmcpWriteCARD8 (buffer, array->data[i])) + return FALSE; + return TRUE; +} + +int +XdmcpWriteARRAY16 (XdmcpBufferPtr buffer, const ARRAY16Ptr array) +{ + int i; + + if (!XdmcpWriteCARD8 (buffer, array->length)) + return FALSE; + for (i = 0; i < (int)array->length; i++) + if (!XdmcpWriteCARD16 (buffer, array->data[i])) + return FALSE; + return TRUE; +} + +int +XdmcpWriteARRAY32 (XdmcpBufferPtr buffer, const ARRAY32Ptr array) +{ + int i; + + if (!XdmcpWriteCARD8 (buffer, array->length)) + return FALSE; + for (i = 0; i < (int)array->length; i++) + if (!XdmcpWriteCARD32 (buffer, array->data[i])) + return FALSE; + return TRUE; +} + +int +XdmcpWriteARRAYofARRAY8 (XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array) +{ + int i; + + if (!XdmcpWriteCARD8 (buffer, array->length)) + return FALSE; + for (i = 0; i < (int)array->length; i++) + if (!XdmcpWriteARRAY8 (buffer, &array->data[i])) + return FALSE; + return TRUE; +} + +int +XdmcpWriteCARD8 ( + XdmcpBufferPtr buffer, + unsigned value) +{ + if (buffer->pointer >= buffer->size) + return FALSE; + buffer->data[buffer->pointer++] = (BYTE) value; + return TRUE; +} + +int +XdmcpWriteCARD16 ( + XdmcpBufferPtr buffer, + unsigned value) +{ + if (!XdmcpWriteCARD8 (buffer, value >> 8)) + return FALSE; + if (!XdmcpWriteCARD8 (buffer, value & 0xff)) + return FALSE; + return TRUE; +} + +int +XdmcpWriteCARD32 ( + XdmcpBufferPtr buffer, + unsigned value) +{ + if (!XdmcpWriteCARD8 (buffer, value >> 24)) + return FALSE; + if (!XdmcpWriteCARD8 (buffer, (value >> 16) & 0xff)) + return FALSE; + if (!XdmcpWriteCARD8 (buffer, (value >> 8) & 0xff)) + return FALSE; + if (!XdmcpWriteCARD8 (buffer, value & 0xff)) + return FALSE; + return TRUE; +} diff --git a/depends/libxcb/depends/libxdmcp/config.h b/depends/libxcb/depends/libxdmcp/config.h new file mode 100644 index 0000000..1704f92 --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/config.h @@ -0,0 +1,188 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Has Wraphelp.c needed for XDM AUTH protocols */ +#define HASXDMAUTH 1 + +/* Define to 1 if you have the `arc4random_buf' function. */ +#define HAVE_ARC4RANDOM_BUF 1 + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the `getentropy' function. */ +#define HAVE_GETENTROPY 1 + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the `ws2_32' library (-lws2_32). */ +/* #undef HAVE_LIBWS2_32 */ + +/* Define to 1 if you have the `lrand48' function. */ +#define HAVE_LRAND48 1 + +/* Define to 1 if you have the <minix/config.h> header file. */ +/* #undef HAVE_MINIX_CONFIG_H */ + +/* Define to 1 if you have the `srand48' function. */ +#define HAVE_SRAND48 1 + +/* Define to 1 if you have the <stdint.h> header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdio.h> header file. */ +#define HAVE_STDIO_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the <sys/random.h> header file. */ +#define HAVE_SYS_RANDOM_H 1 + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the <wchar.h> header file. */ +#define HAVE_WCHAR_H 1 + +/* Define to the sub-directory where libtool stores uninstalled libraries. */ +#define LT_OBJDIR ".libs/" + +/* Name of package */ +#define PACKAGE "libXdmcp" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "https://gitlab.freedesktop.org/xorg/lib/libxdmcp/-/issues" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "libXdmcp" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "libXdmcp 1.1.4" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "libXdmcp" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "1.1.4" + +/* Major version of this package */ +#define PACKAGE_VERSION_MAJOR 1 + +/* Minor version of this package */ +#define PACKAGE_VERSION_MINOR 1 + +/* Patch version of this package */ +#define PACKAGE_VERSION_PATCHLEVEL 4 + +/* Define to 1 if all of the C90 standard headers exist (not just the ones + required in a freestanding environment). This macro is provided for + backward compatibility; new code need not use it. */ +#define STDC_HEADERS 1 + +/* Enable extensions on AIX 3, Interix. */ +#ifndef _ALL_SOURCE +# define _ALL_SOURCE 1 +#endif +/* Enable general extensions on macOS. */ +#ifndef _DARWIN_C_SOURCE +# define _DARWIN_C_SOURCE 1 +#endif +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# define __EXTENSIONS__ 1 +#endif +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif +/* Enable X/Open compliant socket functions that do not require linking + with -lxnet on HP-UX 11.11. */ +#ifndef _HPUX_ALT_XOPEN_SOCKET_API +# define _HPUX_ALT_XOPEN_SOCKET_API 1 +#endif +/* Identify the host operating system as Minix. + This macro does not affect the system headers' behavior. + A future release of Autoconf may stop defining this macro. */ +#ifndef _MINIX +/* # undef _MINIX */ +#endif +/* Enable general extensions on NetBSD. + Enable NetBSD compatibility extensions on Minix. */ +#ifndef _NETBSD_SOURCE +# define _NETBSD_SOURCE 1 +#endif +/* Enable OpenBSD compatibility extensions on NetBSD. + Oddly enough, this does nothing on OpenBSD. */ +#ifndef _OPENBSD_SOURCE +# define _OPENBSD_SOURCE 1 +#endif +/* Define to 1 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_SOURCE +/* # undef _POSIX_SOURCE */ +#endif +/* Define to 2 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_1_SOURCE +/* # undef _POSIX_1_SOURCE */ +#endif +/* Enable POSIX-compatible threading on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# define _POSIX_PTHREAD_SEMANTICS 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */ +#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ +# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */ +#ifndef __STDC_WANT_IEC_60559_BFP_EXT__ +# define __STDC_WANT_IEC_60559_BFP_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */ +#ifndef __STDC_WANT_IEC_60559_DFP_EXT__ +# define __STDC_WANT_IEC_60559_DFP_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */ +#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__ +# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */ +#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__ +# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1 +#endif +/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */ +#ifndef __STDC_WANT_LIB_EXT2__ +# define __STDC_WANT_LIB_EXT2__ 1 +#endif +/* Enable extensions specified by ISO/IEC 24747:2009. */ +#ifndef __STDC_WANT_MATH_SPEC_FUNCS__ +# define __STDC_WANT_MATH_SPEC_FUNCS__ 1 +#endif +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# define _TANDEM_SOURCE 1 +#endif +/* Enable X/Open extensions. Define to 500 only if necessary + to make mbstate_t available. */ +#ifndef _XOPEN_SOURCE +/* # undef _XOPEN_SOURCE */ +#endif + + +/* Version number of package */ +#define VERSION "1.1.4" diff --git a/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h b/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h new file mode 100644 index 0000000..0b531de --- /dev/null +++ b/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h @@ -0,0 +1,181 @@ +/* + * Copyright 1989 Network Computing Devices, Inc., Mountain View, California. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of N.C.D. not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. N.C.D. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + */ + +#ifndef _XDMCP_H_ +#define _XDMCP_H_ + +#include <X11/Xmd.h> + +#include <X11/Xfuncproto.h> + +_XFUNCPROTOBEGIN + +#define XDM_PROTOCOL_VERSION 1 +#define XDM_UDP_PORT 177 + +/* IANA has assigned FF0X:0:0:0:0:0:0:12B as the permanently assigned + * multicast addresses for XDMCP, where X in the prefix may be replaced + * by any valid scope identifier, such as 1 for Node-Local, 2 for Link-Local, + * 5 for Site-Local, and so on. We set the default here to the Link-Local + * version to most closely match the old IPv4 subnet broadcast behavior. + * Both xdm and X -query allow specifying a different address if a different + * scope is defined. + */ +#define XDM_DEFAULT_MCAST_ADDR6 "ff02:0:0:0:0:0:0:12b" + +#define XDM_MAX_MSGLEN 8192 +#define XDM_MIN_RTX 2 +#define XDM_MAX_RTX 32 +#define XDM_RTX_LIMIT 7 +#define XDM_KA_RTX_LIMIT 4 +#define XDM_DEF_DORMANCY (3 * 60) /* 3 minutes */ +#define XDM_MAX_DORMANCY (24 * 60 * 60) /* 24 hours */ + +typedef enum { + BROADCAST_QUERY = 1, QUERY, INDIRECT_QUERY, FORWARD_QUERY, + WILLING, UNWILLING, REQUEST, ACCEPT, DECLINE, MANAGE, REFUSE, + FAILED, KEEPALIVE, ALIVE +} xdmOpCode; + +typedef enum { + XDM_QUERY, XDM_BROADCAST, XDM_INDIRECT, XDM_COLLECT_QUERY, + XDM_COLLECT_BROADCAST_QUERY, XDM_COLLECT_INDIRECT_QUERY, + XDM_START_CONNECTION, XDM_AWAIT_REQUEST_RESPONSE, + XDM_AWAIT_MANAGE_RESPONSE, XDM_MANAGE, XDM_RUN_SESSION, XDM_OFF, + XDM_AWAIT_USER_INPUT, XDM_KEEPALIVE, XDM_AWAIT_ALIVE_RESPONSE, +#if defined(IPv6) && defined(AF_INET6) + XDM_MULTICAST, XDM_COLLECT_MULTICAST_QUERY, +#endif + XDM_KEEP_ME_LAST +} xdmcp_states; + +#ifdef NOTDEF +/* table of hosts */ + +#define XDM_MAX_STR_LEN 21 +#define XDM_MAX_HOSTS 20 +struct xdm_host_table { + struct sockaddr_in sockaddr; + char name[XDM_MAX_STR_LEN]; + char status[XDM_MAX_STR_LEN]; +}; +#endif /* NOTDEF */ + +typedef CARD8 *CARD8Ptr; +typedef CARD16 *CARD16Ptr; +typedef CARD32 *CARD32Ptr; + +typedef struct _ARRAY8 { + CARD16 length; + CARD8Ptr data; +} ARRAY8, *ARRAY8Ptr; + +typedef struct _ARRAY16 { + CARD8 length; + CARD16Ptr data; +} ARRAY16, *ARRAY16Ptr; + +typedef struct _ARRAY32 { + CARD8 length; + CARD32Ptr data; +} ARRAY32, *ARRAY32Ptr; + +typedef struct _ARRAYofARRAY8 { + CARD8 length; + ARRAY8Ptr data; +} ARRAYofARRAY8, *ARRAYofARRAY8Ptr; + +typedef struct _XdmcpHeader { + CARD16 version, opcode, length; +} XdmcpHeader, *XdmcpHeaderPtr; + +typedef struct _XdmcpBuffer { + BYTE *data; + int size; /* size of buffer pointed by to data */ + int pointer; /* current index into data */ + int count; /* bytes read from network into data */ +} XdmcpBuffer, *XdmcpBufferPtr; + +typedef struct _XdmAuthKey { + BYTE data[8]; +} XdmAuthKeyRec, *XdmAuthKeyPtr; + + +/* implementation-independent network address structure. + Equiv to sockaddr* for sockets. */ + +typedef char *XdmcpNetaddr; + +extern int XdmcpWriteARRAY16(XdmcpBufferPtr buffer, const ARRAY16Ptr array); +extern int XdmcpWriteARRAY32(XdmcpBufferPtr buffer, const ARRAY32Ptr array); +extern int XdmcpWriteARRAY8(XdmcpBufferPtr buffer, const ARRAY8Ptr array); +extern int XdmcpWriteARRAYofARRAY8(XdmcpBufferPtr buffer, const ARRAYofARRAY8Ptr array); +extern int XdmcpWriteCARD16(XdmcpBufferPtr buffer, unsigned value); +extern int XdmcpWriteCARD32(XdmcpBufferPtr buffer, unsigned value); +extern int XdmcpWriteCARD8(XdmcpBufferPtr buffer, unsigned value); +extern int XdmcpWriteHeader(XdmcpBufferPtr buffer, const XdmcpHeaderPtr header); + +extern int XdmcpFlush(int fd, XdmcpBufferPtr buffer, XdmcpNetaddr to, int tolen); + +extern int XdmcpReadARRAY16(XdmcpBufferPtr buffer, ARRAY16Ptr array); +extern int XdmcpReadARRAY32(XdmcpBufferPtr buffer, ARRAY32Ptr array); +extern int XdmcpReadARRAY8(XdmcpBufferPtr buffer, ARRAY8Ptr array); +extern int XdmcpReadARRAYofARRAY8(XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array); +extern int XdmcpReadCARD16(XdmcpBufferPtr buffer, CARD16Ptr valuep); +extern int XdmcpReadCARD32(XdmcpBufferPtr buffer, CARD32Ptr valuep); +extern int XdmcpReadCARD8(XdmcpBufferPtr buffer, CARD8Ptr valuep); +extern int XdmcpReadHeader(XdmcpBufferPtr buffer, XdmcpHeaderPtr header); + +extern int XdmcpFill(int fd, XdmcpBufferPtr buffer, XdmcpNetaddr from, int *fromlen); + +extern int XdmcpReadRemaining(const XdmcpBufferPtr buffer); + +extern void XdmcpDisposeARRAY8(ARRAY8Ptr array); +extern void XdmcpDisposeARRAY16(ARRAY16Ptr array); +extern void XdmcpDisposeARRAY32(ARRAY32Ptr array); +extern void XdmcpDisposeARRAYofARRAY8(ARRAYofARRAY8Ptr array); + +extern int XdmcpCopyARRAY8(const ARRAY8Ptr src, ARRAY8Ptr dst); + +extern int XdmcpARRAY8Equal(const ARRAY8Ptr array1, const ARRAY8Ptr array2); + +extern void XdmcpGenerateKey (XdmAuthKeyPtr key); +extern void XdmcpIncrementKey (XdmAuthKeyPtr key); +extern void XdmcpDecrementKey (XdmAuthKeyPtr key); +#ifdef HASXDMAUTH +extern void XdmcpWrap(unsigned char *input, unsigned char *wrapper, unsigned char *output, int bytes); +extern void XdmcpUnwrap(unsigned char *input, unsigned char *wrapper, unsigned char *output, int bytes); +#endif + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +extern int XdmcpCompareKeys (const XdmAuthKeyPtr a, const XdmAuthKeyPtr b); + +extern int XdmcpAllocARRAY16 (ARRAY16Ptr array, int length); +extern int XdmcpAllocARRAY32 (ARRAY32Ptr array, int length); +extern int XdmcpAllocARRAY8 (ARRAY8Ptr array, int length); +extern int XdmcpAllocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length); + +extern int XdmcpReallocARRAY16 (ARRAY16Ptr array, int length); +extern int XdmcpReallocARRAY32 (ARRAY32Ptr array, int length); +extern int XdmcpReallocARRAY8 (ARRAY8Ptr array, int length); +extern int XdmcpReallocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length); + +_XFUNCPROTOEND + +#endif /* _XDMCP_H_ */ |