54 #include "magick/studio.h"
55 #include "magick/cache.h"
56 #include "magick/cache-private.h"
57 #include "magick/distribute-cache.h"
58 #include "magick/distribute-cache-private.h"
59 #include "magick/exception.h"
60 #include "magick/exception-private.h"
61 #include "magick/geometry.h"
62 #include "magick/image.h"
63 #include "magick/image-private.h"
64 #include "magick/list.h"
65 #include "magick/locale_.h"
66 #include "magick/memory_.h"
67 #include "magick/nt-base-private.h"
68 #include "magick/policy.h"
69 #include "magick/random_.h"
70 #include "magick/registry.h"
71 #include "magick/splay-tree.h"
72 #include "magick/string_.h"
73 #include "magick/string-private.h"
74 #include "magick/version.h"
75 #include "magick/version-private.h"
76 #undef MAGICKCORE_HAVE_DISTRIBUTE_CACHE
77 #if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)
78 #include <netinet/in.h>
80 #include <sys/socket.h>
81 #include <arpa/inet.h>
82 #define CHAR_TYPE_CAST
83 #define CLOSE_SOCKET(socket) (void) close(socket)
84 #define HANDLER_RETURN_TYPE void *
85 #define HANDLER_RETURN_VALUE (void *) NULL
86 #define SOCKET_TYPE int
87 #define LENGTH_TYPE size_t
88 #define MAGICKCORE_HAVE_DISTRIBUTE_CACHE
89 #elif defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__)
90 #define CHAR_TYPE_CAST (char *)
91 #define CLOSE_SOCKET(socket) (void) closesocket(socket)
92 #define HANDLER_RETURN_TYPE DWORD WINAPI
93 #define HANDLER_RETURN_VALUE 0
94 #define SOCKET_TYPE SOCKET
95 #define LENGTH_TYPE int
96 #define MAGICKCORE_HAVE_DISTRIBUTE_CACHE
99 #define CLOSE_SOCKET(socket) (void) close(socket)
101 #define CLOSE_SOCKET(socket)
103 #define HANDLER_RETURN_TYPE void *
104 #define HANDLER_RETURN_VALUE (void *) NULL
105 #define SOCKET_TYPE int
106 #define LENGTH_TYPE size_t
109 #define send(file,buffer,length,flags) 0
110 #define recv(file,buffer,length,flags) 0
116 #define DPCHostname "127.0.0.1"
117 #define DPCPendingConnections 10
119 #define DPCSessionKeyLength 8
121 # define MSG_NOSIGNAL 0
147 static inline MagickOffsetType dpc_read(
int file,
const MagickSizeType length,
148 unsigned char *magick_restrict message)
156 #if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)
157 magick_unreferenced(file);
158 magick_unreferenced(message);
161 for (i=0; i < (MagickOffsetType) length; i+=count)
163 count=recv(file,CHAR_TYPE_CAST message+i,(LENGTH_TYPE) MagickMin(length-i,
164 (MagickSizeType) MAGICK_SSIZE_MAX),0);
175 static int ConnectPixelCacheServer(
const char *hostname,
const int port,
178 #if defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)
180 service[MagickPathExtent],
203 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
204 NTInitializeWinsock(MagickTrue);
206 (void) memset(&hint,0,
sizeof(hint));
207 hint.ai_family=AF_INET;
208 hint.ai_socktype=SOCK_STREAM;
209 hint.ai_flags=AI_PASSIVE;
210 (void) FormatLocaleString(service,MagickPathExtent,
"%d",port);
211 status=getaddrinfo(hostname,service,&hint,&result);
214 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
215 "DistributedPixelCache",
"'%s': %s",hostname,GetExceptionMessage(errno));
218 client_socket=socket(result->ai_family,result->ai_socktype,
219 result->ai_protocol);
220 if (client_socket == -1)
222 freeaddrinfo(result);
223 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
224 "DistributedPixelCache",
"'%s': %s",hostname,GetExceptionMessage(errno));
227 status=connect(client_socket,result->ai_addr,(socklen_t) result->ai_addrlen);
228 freeaddrinfo(result);
231 CLOSE_SOCKET(client_socket);
232 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
233 "DistributedPixelCache",
"'%s': %s",hostname,GetExceptionMessage(errno));
236 count=recv(client_socket,CHAR_TYPE_CAST session_key,
sizeof(session_key),0);
239 CLOSE_SOCKET(client_socket);
240 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
241 "DistributedPixelCache",
"'%s': %s",hostname,GetExceptionMessage(errno));
247 shared_secret=GetPolicyValue(
"cache:shared-secret");
248 if (shared_secret == (
char *) NULL)
250 CLOSE_SOCKET(client_socket);
251 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
252 "DistributedPixelCache",
"'%s': shared secret required",hostname);
255 nonce=StringToStringInfo(shared_secret);
256 if (GetMagickCoreSignature(nonce) != *session_key)
258 CLOSE_SOCKET(client_socket);
259 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
260 "DistributedPixelCache",
"'%s': authentication failed",hostname);
263 shared_secret=DestroyString(shared_secret);
264 nonce=DestroyStringInfo(nonce);
265 return(client_socket);
267 (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,
268 "DelegateLibrarySupportNotBuiltIn",
"distributed pixel cache");
292 hosts=(
char *) GetImageRegistry(StringRegistryType,
"cache:hosts",exception);
293 if (hosts == (
char *) NULL)
296 return(AcquireString(DPCHostname));
298 (void) SubstituteString(&hosts,
",",
" ");
299 hostlist=StringToArgv(hosts,&argc);
300 hosts=DestroyString(hosts);
301 if (hostlist == (
char **) NULL)
304 return(AcquireString(DPCHostname));
306 hosts=AcquireString(hostlist[(
id++ % (argc-1))+1]);
307 for (i=0; i < (ssize_t) argc; i++)
308 hostlist[i]=DestroyString(hostlist[i]);
309 hostlist=(
char **) RelinquishMagickMemory(hostlist);
310 (void) SubstituteString(&hosts,
":",
" ");
311 hostlist=StringToArgv(hosts,&argc);
312 if (hostlist == (
char **) NULL)
315 return(AcquireString(DPCHostname));
317 host=AcquireString(hostlist[1]);
318 if (hostlist[2] == (
char *) NULL)
321 *port=StringToLong(hostlist[2]);
322 for (i=0; i < (ssize_t) argc; i++)
323 hostlist[i]=DestroyString(hostlist[i]);
324 hostlist=(
char **) RelinquishMagickMemory(hostlist);
344 sizeof(*server_info));
345 (void) memset(server_info,0,
sizeof(*server_info));
346 server_info->signature=MagickCoreSignature;
348 hostname=GetHostname(&server_info->port,exception);
350 server_info->file=ConnectPixelCacheServer(hostname,server_info->port,
351 &session_key,exception);
352 if (server_info->file == -1)
353 server_info=DestroyDistributeCacheInfo(server_info);
356 server_info->session_key=session_key;
357 (void) CopyMagickString(server_info->hostname,hostname,MagickPathExtent);
358 server_info->debug=GetLogEventMask() & CacheEvent ? MagickTrue :
361 hostname=DestroyString(hostname);
393 assert(server_info->signature == MagickCoreSignature);
394 if (server_info->file > 0)
395 CLOSE_SOCKET(server_info->file);
396 server_info->signature=(~MagickCoreSignature);
427 static MagickBooleanType DestroyDistributeCache(
SplayTreeInfo *registry,
428 const size_t session_key)
431 key = (MagickAddressType) session_key;
436 return(DeleteNodeFromSplayTree(registry,(
const void *) key));
439 static inline MagickOffsetType dpc_send(
int file,
const MagickSizeType length,
440 const void *magick_restrict message)
448 #if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)
449 magick_unreferenced(file);
450 magick_unreferenced(message);
457 for (i=0; i < (MagickOffsetType) length; i+=count)
459 count=(MagickOffsetType) send(file,CHAR_TYPE_CAST message+i,(LENGTH_TYPE)
460 MagickMin(length-i,(MagickSizeType) MAGICK_SSIZE_MAX),MSG_NOSIGNAL);
471 static MagickBooleanType OpenDistributeCache(
SplayTreeInfo *registry,
int file,
478 key = (MagickAddressType) session_key;
490 message[MagickPathExtent],
497 if (image == (
Image *) NULL)
499 length=
sizeof(image->storage_class)+
sizeof(image->colorspace)+
500 sizeof(image->channels)+
sizeof(image->columns)+
sizeof(image->rows);
501 count=dpc_read(file,length,message);
502 if (count != (MagickOffsetType) length)
508 (void) memcpy(&image->storage_class,p,
sizeof(image->storage_class));
509 p+=
sizeof(image->storage_class);
510 (void) memcpy(&image->colorspace,p,
sizeof(image->colorspace));
511 p+=
sizeof(image->colorspace);
512 (void) memcpy(&image->channels,p,
sizeof(image->channels));
513 p+=
sizeof(image->channels);
514 (void) memcpy(&image->columns,p,
sizeof(image->columns));
515 p+=
sizeof(image->columns);
516 (void) memcpy(&image->rows,p,
sizeof(image->rows));
517 p+=
sizeof(image->rows);
518 if (SyncImagePixelCache(image,exception) == MagickFalse)
520 status=AddValueToSplayTree(registry,(
const void *) key,image);
524 static MagickBooleanType ReadDistributeCacheIndexes(
SplayTreeInfo *registry,
537 key = (MagickAddressType) session_key;
549 message[MagickPathExtent],
555 image=(
Image *) GetValueFromSplayTree(registry,(
const void *) key);
556 if (image == (
Image *) NULL)
558 length=
sizeof(region.width)+
sizeof(region.height)+
sizeof(region.x)+
559 sizeof(region.y)+
sizeof(length);
560 count=dpc_read(file,length,message);
561 if (count != (MagickOffsetType) length)
564 (void) memcpy(®ion.width,q,
sizeof(region.width));
565 q+=
sizeof(region.width);
566 (void) memcpy(®ion.height,q,
sizeof(region.height));
567 q+=
sizeof(region.height);
568 (void) memcpy(®ion.x,q,
sizeof(region.x));
570 (void) memcpy(®ion.y,q,
sizeof(region.y));
572 (void) memcpy(&length,q,
sizeof(length));
574 p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
578 indexes=GetVirtualIndexQueue(image);
579 count=dpc_send(file,length,indexes);
580 if (count != (MagickOffsetType) length)
585 static MagickBooleanType ReadDistributeCachePixels(
SplayTreeInfo *registry,
595 key = (MagickAddressType) session_key;
607 message[MagickPathExtent],
613 image=(
Image *) GetValueFromSplayTree(registry,(
const void *) key);
614 if (image == (
Image *) NULL)
616 length=
sizeof(region.width)+
sizeof(region.height)+
sizeof(region.x)+
617 sizeof(region.y)+
sizeof(length);
618 count=dpc_read(file,length,message);
619 if (count != (MagickOffsetType) length)
622 (void) memcpy(®ion.width,q,
sizeof(region.width));
623 q+=
sizeof(region.width);
624 (void) memcpy(®ion.height,q,
sizeof(region.height));
625 q+=
sizeof(region.height);
626 (void) memcpy(®ion.x,q,
sizeof(region.x));
628 (void) memcpy(®ion.y,q,
sizeof(region.y));
630 (void) memcpy(&length,q,
sizeof(length));
632 p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
636 count=dpc_send(file,length,p);
637 if (count != (MagickOffsetType) length)
642 static void *RelinquishImageRegistry(
void *image)
644 return((
void *) DestroyImageList((
Image *) image));
647 static MagickBooleanType WriteDistributeCacheIndexes(
SplayTreeInfo *registry,
657 key = (MagickAddressType) session_key;
671 message[MagickPathExtent],
677 image=(
Image *) GetValueFromSplayTree(registry,(
const void *) key);
678 if (image == (
Image *) NULL)
680 length=
sizeof(region.width)+
sizeof(region.height)+
sizeof(region.x)+
681 sizeof(region.y)+
sizeof(length);
682 count=dpc_read(file,length,message);
683 if (count != (MagickOffsetType) length)
686 (void) memcpy(®ion.width,p,
sizeof(region.width));
687 p+=
sizeof(region.width);
688 (void) memcpy(®ion.height,p,
sizeof(region.height));
689 p+=
sizeof(region.height);
690 (void) memcpy(®ion.x,p,
sizeof(region.x));
692 (void) memcpy(®ion.y,p,
sizeof(region.y));
694 (void) memcpy(&length,p,
sizeof(length));
696 q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
700 indexes=GetAuthenticIndexQueue(image);
701 count=dpc_read(file,length,(
unsigned char *) indexes);
702 if (count != (MagickOffsetType) length)
704 return(SyncAuthenticPixels(image,exception));
707 static MagickBooleanType WriteDistributeCachePixels(
SplayTreeInfo *registry,
714 key = (MagickAddressType) session_key;
729 message[MagickPathExtent],
735 image=(
Image *) GetValueFromSplayTree(registry,(
const void *) key);
736 if (image == (
Image *) NULL)
738 length=
sizeof(region.width)+
sizeof(region.height)+
sizeof(region.x)+
739 sizeof(region.y)+
sizeof(length);
740 count=dpc_read(file,length,message);
741 if (count != (MagickOffsetType) length)
744 (void) memcpy(®ion.width,p,
sizeof(region.width));
745 p+=
sizeof(region.width);
746 (void) memcpy(®ion.height,p,
sizeof(region.height));
747 p+=
sizeof(region.height);
748 (void) memcpy(®ion.x,p,
sizeof(region.x));
750 (void) memcpy(®ion.y,p,
sizeof(region.y));
752 (void) memcpy(&length,p,
sizeof(length));
754 q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
758 count=dpc_read(file,length,(
unsigned char *) q);
759 if (count != (MagickOffsetType) length)
761 return(SyncAuthenticPixels(image,exception));
764 static HANDLER_RETURN_TYPE DistributePixelCacheClient(
void *socket)
773 status = MagickFalse;
797 shared_secret=GetPolicyValue(
"cache:shared-secret");
798 if (shared_secret == (
char *) NULL)
799 ThrowFatalException(CacheFatalError,
"shared secret required");
800 nonce=StringToStringInfo(shared_secret);
801 shared_secret=DestroyString(shared_secret);
802 session_key=GetMagickCoreSignature(nonce);
803 nonce=DestroyStringInfo(nonce);
804 exception=AcquireExceptionInfo();
808 registry=NewSplayTree((
int (*)(
const void *,
const void *)) NULL,
809 (
void *(*)(
void *)) NULL,RelinquishImageRegistry);
810 client_socket=(*(SOCKET_TYPE *) socket);
811 count=dpc_send(client_socket,
sizeof(session_key),&session_key);
812 for (status=MagickFalse; ; )
814 count=dpc_read(client_socket,1,(
unsigned char *) &command);
817 count=dpc_read(client_socket,
sizeof(key),(
unsigned char *) &key);
818 if ((count != (MagickOffsetType)
sizeof(key)) || (key != session_key))
824 status=OpenDistributeCache(registry,client_socket,session_key,
826 count=dpc_send(client_socket,
sizeof(status),&status);
831 status=ReadDistributeCachePixels(registry,client_socket,session_key,
837 status=ReadDistributeCacheIndexes(registry,client_socket,
838 session_key,exception);
843 status=WriteDistributeCachePixels(registry,client_socket,session_key,
849 status=WriteDistributeCacheIndexes(registry,client_socket,
850 session_key,exception);
855 status=DestroyDistributeCache(registry,session_key);
861 if (status == MagickFalse)
866 count=dpc_send(client_socket,
sizeof(status),&status);
867 CLOSE_SOCKET(client_socket);
868 exception=DestroyExceptionInfo(exception);
869 registry=DestroySplayTree(registry);
870 return(HANDLER_RETURN_VALUE);
873 MagickExport
void DistributePixelCacheServer(
const int port,
876 #if defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)
878 service[MagickPathExtent];
883 #if defined(MAGICKCORE_THREAD_SUPPORT)
889 #elif defined(MAGICKCORE_WINDOWS_SUPPORT)
913 assert(exception->signature == MagickCoreSignature);
914 magick_unreferenced(exception);
915 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
916 NTInitializeWinsock(MagickFalse);
918 (void) memset(&hint,0,
sizeof(hint));
919 hint.ai_family=AF_INET;
920 hint.ai_socktype=SOCK_STREAM;
921 hint.ai_flags=AI_PASSIVE;
922 (void) FormatLocaleString(service,MagickPathExtent,
"%d",port);
923 status=getaddrinfo((
const char *) NULL,service,&hint,&result);
925 ThrowFatalException(CacheFatalError,
"UnableToListen");
926 server_socket=(SOCKET_TYPE) 0;
927 for (p=result; p != (
struct addrinfo *) NULL; p=p->ai_next)
932 server_socket=socket(p->ai_family,p->ai_socktype,p->ai_protocol);
933 if (server_socket == -1)
936 status=setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,
937 CHAR_TYPE_CAST &one,(socklen_t)
sizeof(one));
940 CLOSE_SOCKET(server_socket);
943 status=bind(server_socket,p->ai_addr,(socklen_t) p->ai_addrlen);
946 CLOSE_SOCKET(server_socket);
951 if (p == (
struct addrinfo *) NULL)
952 ThrowFatalException(CacheFatalError,
"UnableToBind");
953 freeaddrinfo(result);
954 status=listen(server_socket,DPCPendingConnections);
956 ThrowFatalException(CacheFatalError,
"UnableToListen");
957 #if defined(MAGICKCORE_THREAD_SUPPORT)
958 pthread_attr_init(&attributes);
968 length=(socklen_t)
sizeof(address);
969 client_socket=accept(server_socket,(
struct sockaddr *) &address,&length);
970 if (client_socket == -1)
971 ThrowFatalException(CacheFatalError,
"UnableToEstablishConnection");
972 #if defined(MAGICKCORE_THREAD_SUPPORT)
973 status=pthread_create(&threads,&attributes,DistributePixelCacheClient,
974 (
void *) &client_socket);
976 ThrowFatalException(CacheFatalError,
"UnableToCreateClientThread");
977 #elif defined(MAGICKCORE_WINDOWS_SUPPORT)
978 if (CreateThread(0,0,DistributePixelCacheClient,(
void*) &client_socket,0,&threadID) == (HANDLE) NULL)
979 ThrowFatalException(CacheFatalError,
"UnableToCreateClientThread");
985 magick_unreferenced(port);
986 magick_unreferenced(exception);
987 ThrowFatalException(MissingDelegateError,
"DelegateLibrarySupportNotBuiltIn");
1017 assert(server_info->signature == MagickCoreSignature);
1018 return(server_info->file);
1045 MagickPrivate
const char *GetDistributeCacheHostname(
1049 assert(server_info->signature == MagickCoreSignature);
1050 return(server_info->hostname);
1079 assert(server_info->signature == MagickCoreSignature);
1080 return(server_info->port);
1108 MagickPrivate MagickBooleanType OpenDistributePixelCache(
1118 message[MagickPathExtent],
1125 assert(server_info->signature == MagickCoreSignature);
1126 assert(image != (
Image *) NULL);
1127 assert(image->signature == MagickCoreSignature);
1133 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1134 p+=
sizeof(server_info->session_key);
1135 (void) memcpy(p,&image->storage_class,
sizeof(image->storage_class));
1136 p+=
sizeof(image->storage_class);
1137 (void) memcpy(p,&image->colorspace,
sizeof(image->colorspace));
1138 p+=
sizeof(image->colorspace);
1139 (void) memcpy(p,&image->channels,
sizeof(image->channels));
1140 p+=
sizeof(image->channels);
1141 (void) memcpy(p,&image->columns,
sizeof(image->columns));
1142 p+=
sizeof(image->columns);
1143 (void) memcpy(p,&image->rows,
sizeof(image->rows));
1144 p+=
sizeof(image->rows);
1145 count=dpc_send(server_info->file,p-message,message);
1146 if (count != (MagickOffsetType) (p-message))
1147 return(MagickFalse);
1149 count=dpc_read(server_info->file,
sizeof(status),(
unsigned char *) &status);
1150 if (count != (MagickOffsetType)
sizeof(status))
1151 return(MagickFalse);
1188 MagickPrivate MagickOffsetType ReadDistributePixelCacheIndexes(
1190 const MagickSizeType length,
unsigned char *indexes)
1196 message[MagickPathExtent],
1203 assert(server_info->signature == MagickCoreSignature);
1205 assert(indexes != (
unsigned char *) NULL);
1206 if (length > (MagickSizeType) MAGICK_SSIZE_MAX)
1210 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1211 p+=
sizeof(server_info->session_key);
1212 (void) memcpy(p,®ion->width,
sizeof(region->width));
1213 p+=
sizeof(region->width);
1214 (void) memcpy(p,®ion->height,
sizeof(region->height));
1215 p+=
sizeof(region->height);
1216 (void) memcpy(p,®ion->x,
sizeof(region->x));
1217 p+=
sizeof(region->x);
1218 (void) memcpy(p,®ion->y,
sizeof(region->y));
1219 p+=
sizeof(region->y);
1220 (void) memcpy(p,&length,
sizeof(length));
1222 count=dpc_send(server_info->file,p-message,message);
1223 if (count != (MagickOffsetType) (p-message))
1225 return(dpc_read(server_info->file,length,indexes));
1261 MagickPrivate MagickOffsetType ReadDistributePixelCachePixels(
1263 const MagickSizeType length,
unsigned char *magick_restrict pixels)
1269 message[MagickPathExtent],
1276 assert(server_info->signature == MagickCoreSignature);
1278 assert(pixels != (
unsigned char *) NULL);
1279 if (length > (MagickSizeType) MAGICK_SSIZE_MAX)
1283 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1284 p+=
sizeof(server_info->session_key);
1285 (void) memcpy(p,®ion->width,
sizeof(region->width));
1286 p+=
sizeof(region->width);
1287 (void) memcpy(p,®ion->height,
sizeof(region->height));
1288 p+=
sizeof(region->height);
1289 (void) memcpy(p,®ion->x,
sizeof(region->x));
1290 p+=
sizeof(region->x);
1291 (void) memcpy(p,®ion->y,
sizeof(region->y));
1292 p+=
sizeof(region->y);
1293 (void) memcpy(p,&length,
sizeof(length));
1295 count=dpc_send(server_info->file,p-message,message);
1296 if (count != (MagickOffsetType) (p-message))
1298 return(dpc_read(server_info->file,length,pixels));
1325 MagickPrivate MagickBooleanType RelinquishDistributePixelCache(
1335 message[MagickPathExtent],
1342 assert(server_info->signature == MagickCoreSignature);
1345 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1346 p+=
sizeof(server_info->session_key);
1347 count=dpc_send(server_info->file,p-message,message);
1348 if (count != (MagickOffsetType) (p-message))
1349 return(MagickFalse);
1351 count=dpc_read(server_info->file,
sizeof(status),(
unsigned char *) &status);
1352 if (count != (MagickOffsetType)
sizeof(status))
1353 return(MagickFalse);
1390 MagickPrivate MagickOffsetType WriteDistributePixelCacheIndexes(
1392 const MagickSizeType length,
const unsigned char *indexes)
1398 message[MagickPathExtent],
1405 assert(server_info->signature == MagickCoreSignature);
1407 assert(indexes != (
unsigned char *) NULL);
1408 if (length > (MagickSizeType) MAGICK_SSIZE_MAX)
1412 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1413 p+=
sizeof(server_info->session_key);
1414 (void) memcpy(p,®ion->width,
sizeof(region->width));
1415 p+=
sizeof(region->width);
1416 (void) memcpy(p,®ion->height,
sizeof(region->height));
1417 p+=
sizeof(region->height);
1418 (void) memcpy(p,®ion->x,
sizeof(region->x));
1419 p+=
sizeof(region->x);
1420 (void) memcpy(p,®ion->y,
sizeof(region->y));
1421 p+=
sizeof(region->y);
1422 (void) memcpy(p,&length,
sizeof(length));
1424 count=dpc_send(server_info->file,p-message,message);
1425 if (count != (MagickOffsetType) (p-message))
1427 return(dpc_send(server_info->file,length,indexes));
1464 MagickPrivate MagickOffsetType WriteDistributePixelCachePixels(
1466 const MagickSizeType length,
const unsigned char *magick_restrict pixels)
1472 message[MagickPathExtent],
1479 assert(server_info->signature == MagickCoreSignature);
1481 assert(pixels != (
const unsigned char *) NULL);
1482 if (length > (MagickSizeType) MAGICK_SSIZE_MAX)
1486 (void) memcpy(p,&server_info->session_key,
sizeof(server_info->session_key));
1487 p+=
sizeof(server_info->session_key);
1488 (void) memcpy(p,®ion->width,
sizeof(region->width));
1489 p+=
sizeof(region->width);
1490 (void) memcpy(p,®ion->height,
sizeof(region->height));
1491 p+=
sizeof(region->height);
1492 (void) memcpy(p,®ion->x,
sizeof(region->x));
1493 p+=
sizeof(region->x);
1494 (void) memcpy(p,®ion->y,
sizeof(region->y));
1495 p+=
sizeof(region->y);
1496 (void) memcpy(p,&length,
sizeof(length));
1498 count=dpc_send(server_info->file,p-message,message);
1499 if (count != (MagickOffsetType) (p-message))
1501 return(dpc_send(server_info->file,length,pixels));