% MagickCore Distributed Pixel Cache Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% January 2013 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/exception-private.h"
#include "MagickCore/geometry.h"
#include "MagickCore/image.h"
+#include "MagickCore/list.h"
#include "MagickCore/locale_.h"
#include "MagickCore/memory_.h"
+#include "MagickCore/nt-base-private.h"
+#include "MagickCore/pixel.h"
#include "MagickCore/policy.h"
#include "MagickCore/random_.h"
#include "MagickCore/registry.h"
#include "MagickCore/splay-tree.h"
#include "MagickCore/string_.h"
#include "MagickCore/string-private.h"
-#if defined(MAGICKCORE_HAVE_SOCKET)
+#include "MagickCore/version.h"
+#include "MagickCore/version-private.h"
+#if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)
#include <netinet/in.h>
#include <netdb.h>
#include <sys/socket.h>
#include <arpa/inet.h>
+#else
+#undef send
+#undef recv
+#define send(file,buffer,length,flags) 0
+#define recv(file,buffer,length,flags) 0
#endif
\f
/*
Define declarations.
*/
#define DPCHostname "127.0.0.1"
-#define DPCPendingConnections 5
+#define DPCPendingConnections 10
#define DPCPort 6668
#define DPCSessionKeyLength 8
-\f
-/*
- Typedef declarations.
-*/
-typedef struct _ClientInfo
-{
- int
- socket;
-} ClientInfo;
+#ifndef MSG_NOSIGNAL
+# define MSG_NOSIGNAL 0
+#endif
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
*/
-#if defined(MAGICKCORE_HAVE_SOCKET)
-static MagickSizeType CRC64(const unsigned char *message,const size_t length)
+static inline MagickSizeType MagickMin(const MagickSizeType x,
+ const MagickSizeType y)
{
- MagickSizeType
- crc;
+ if (x < y)
+ return(x);
+ return(y);
+}
- register ssize_t
+static inline MagickOffsetType dpc_read(int file,const MagickSizeType length,
+ unsigned char *restrict message)
+{
+ register MagickOffsetType
i;
- static MagickBooleanType
- crc_initial = MagickFalse;
-
- static MagickSizeType
- crc_xor[256];
+ ssize_t
+ count;
- if (crc_initial == MagickFalse)
- {
- MagickSizeType
- alpha;
+#if !defined(MAGICKCORE_HAVE_SOCKET) || !defined(MAGICKCORE_THREAD_SUPPORT)
+ magick_unreferenced(file);
+ magick_unreferenced(message);
+#endif
- for (i=0; i < 256; i++)
+ count=0;
+ for (i=0; i < (MagickOffsetType) length; i+=count)
+ {
+ count=recv(file,message+i,(size_t) MagickMin(length-i,(MagickSizeType)
+ SSIZE_MAX),0);
+ if (count <= 0)
{
- register ssize_t
- j;
-
- alpha=(MagickSizeType) i;
- for (j=0; j < 8; j++)
- {
- if ((alpha & 0x01) == 0)
- alpha>>=1;
- else
- alpha=(MagickSizeType) ((alpha >> 1) ^
- MagickULLConstant(0xd800000000000000));
- }
- crc_xor[i]=alpha;
+ count=0;
+ if (errno != EINTR)
+ break;
}
- crc_initial=MagickTrue;
- }
- crc=0;
- for (i=0; i < (ssize_t) length; i++)
- crc=crc_xor[(crc ^ message[i]) & 0xff] ^ (crc >> 8);
- return(crc);
+ }
+ return(i);
}
-#endif
static int ConnectPixelCacheServer(const char *hostname,const int port,
- MagickSizeType *session_key,ExceptionInfo *exception)
+ size_t *session_key,ExceptionInfo *exception)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
+#if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)
char
- secret[MaxTextExtent];
+ service[MaxTextExtent];
const char
*shared_secret;
ssize_t
count;
- struct hostent
- *host;
-
- struct sockaddr_in
- address;
+ struct addrinfo
+ hint,
+ *result;
unsigned char
- session[MaxTextExtent];
+ secret[MaxTextExtent];
/*
Connect to distributed pixel cache and get session key.
"DistributedPixelCache","'%s'","shared secret expected");
return(-1);
}
- (void) CopyMagickString((char *) session,shared_secret,MaxTextExtent-
- DPCSessionKeyLength);
- host=gethostbyname(hostname);
- client_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
+ (void) ResetMagickMemory(&hint,0,sizeof(hint));
+ hint.ai_family=AF_INET;
+ hint.ai_socktype=SOCK_STREAM;
+ hint.ai_flags=AI_PASSIVE;
+ (void) FormatLocaleString(service,MaxTextExtent,"%d",port);
+ status=getaddrinfo(hostname,service,&hint,&result);
+ if (status != 0)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
+ "DistributedPixelCache","'%s'",hostname);
+ return(-1);
+ }
+ client_socket=socket(result->ai_family,result->ai_socktype,
+ result->ai_protocol);
if (client_socket == -1)
{
+ (void) close(client_socket);
(void) ThrowMagickException(exception,GetMagickModule(),CacheError,
"DistributedPixelCache","'%s'",hostname);
return(-1);
}
- (void) ResetMagickMemory(&address,0,sizeof(address));
- address.sin_family=AF_INET;
- address.sin_port=htons((uint16_t) port);
- address.sin_addr=(*((struct in_addr *) host->h_addr));
- status=connect(client_socket,(struct sockaddr *) &address,(socklen_t)
- sizeof(struct sockaddr));
+ status=connect(client_socket,result->ai_addr,result->ai_addrlen);
if (status == -1)
{
(void) ThrowMagickException(exception,GetMagickModule(),CacheError,
count=recv(client_socket,secret,MaxTextExtent,0);
if (count != -1)
{
- (void) memcpy(session+strlen(shared_secret),secret,(size_t) count);
- *session_key=CRC64(session,strlen(shared_secret)+count);
+ StringInfo
+ *nonce;
+
+ nonce=AcquireStringInfo(count);
+ (void) memcpy(GetStringInfoDatum(nonce),secret,(size_t) count);
+ *session_key=GetMagickSignature(nonce);
+ nonce=DestroyStringInfo(nonce);
}
if (*session_key == 0)
{
/*
Parse host list (e.g. 192.168.100.1:6668,192.168.100.2:6668).
*/
- hosts=(char *) GetImageRegistry(StringRegistryType,"cache:hosts",
- exception);
+ hosts=(char *) GetImageRegistry(StringRegistryType,"cache:hosts",exception);
if (hosts == (char *) NULL)
{
*port=DPCPort;
*hostname;
DistributeCacheInfo
- *distribute_cache_info;
+ *server_info;
- MagickSizeType
+ size_t
session_key;
- distribute_cache_info=(DistributeCacheInfo *) AcquireMagickMemory(
- sizeof(*distribute_cache_info));
- if (distribute_cache_info == (DistributeCacheInfo *) NULL)
- ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- (void) ResetMagickMemory(distribute_cache_info,0,
- sizeof(*distribute_cache_info));
- distribute_cache_info->signature=MagickSignature;
/*
- Contact pixel cache server.
+ Connect to the distributed pixel cache server.
*/
- distribute_cache_info->port=0;
- hostname=GetHostname(&distribute_cache_info->port,exception);
+ server_info=(DistributeCacheInfo *) AcquireMagickMemory(sizeof(*server_info));
+ if (server_info == (DistributeCacheInfo *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+ (void) ResetMagickMemory(server_info,0,sizeof(*server_info));
+ server_info->signature=MagickSignature;
+ server_info->port=0;
+ hostname=GetHostname(&server_info->port,exception);
session_key=0;
- distribute_cache_info->file=ConnectPixelCacheServer(hostname,
- distribute_cache_info->port,&session_key,exception);
- distribute_cache_info->session_key=session_key;
- (void) CopyMagickString(distribute_cache_info->hostname,hostname,
- MaxTextExtent);
+ server_info->file=ConnectPixelCacheServer(hostname,server_info->port,
+ &session_key,exception);
+ server_info->session_key=session_key;
+ (void) CopyMagickString(server_info->hostname,hostname,MaxTextExtent);
hostname=DestroyString(hostname);
- if (distribute_cache_info->file == -1)
- distribute_cache_info=DestroyDistributeCacheInfo(distribute_cache_info);
- return(distribute_cache_info);
+ if (server_info->file == -1)
+ server_info=DestroyDistributeCacheInfo(server_info);
+ server_info->debug=IsEventLogging();
+ return(server_info);
}
\f
/*
% The format of the DestroyDistributeCacheInfo method is:
%
% DistributeCacheInfo *DestroyDistributeCacheInfo(
-% DistributeCacheInfo *distribute_cache_info)
+% DistributeCacheInfo *server_info)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
*/
MagickPrivate DistributeCacheInfo *DestroyDistributeCacheInfo(
- DistributeCacheInfo *distribute_cache_info)
+ DistributeCacheInfo *server_info)
{
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
- distribute_cache_info->signature=(~MagickSignature);
- distribute_cache_info=(DistributeCacheInfo *) RelinquishMagickMemory(
- distribute_cache_info);
- return(distribute_cache_info);
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
+ if (server_info->file > 0)
+ (void) close(server_info->file);
+ server_info->signature=(~MagickSignature);
+ server_info=(DistributeCacheInfo *) RelinquishMagickMemory(server_info);
+ return(server_info);
}
\f
/*
%
% The format of the DistributePixelCacheServer() method is:
%
-% void DistributePixelCacheServer(const size_t port)
+% void DistributePixelCacheServer(const int port)
%
% A description of each parameter follows:
%
%
*/
-#if defined(MAGICKCORE_HAVE_SOCKET)
-static MagickBooleanType DestroyDistributeCache(SplayTreeInfo *image_registry,
- int file,const MagickSizeType session_key)
+static MagickBooleanType DestroyDistributeCache(SplayTreeInfo *registry,
+ int magick_unused(file),const size_t session_key)
{
- return(DeleteNodeFromSplayTree(image_registry,(const void *) session_key));
+ /*
+ Destroy distributed pixel cache.
+ */
+ magick_unreferenced(file);
+ return(DeleteNodeFromSplayTree(registry,(const void *) session_key));
}
-static MagickBooleanType OpenDistributeCache(SplayTreeInfo *image_registry,
- int file,const MagickSizeType session_key)
+static inline MagickOffsetType dpc_send(int file,const MagickSizeType length,
+ const unsigned char *restrict message)
{
- ExceptionInfo
- *exception;
+ MagickOffsetType
+ count;
+
+ register MagickOffsetType
+ i;
+#if !defined(MAGICKCORE_HAVE_SOCKET) || !defined(MAGICKCORE_THREAD_SUPPORT)
+ magick_unreferenced(file);
+ magick_unreferenced(message);
+#endif
+
+ /*
+ Ensure a complete message is sent.
+ */
+ count=0;
+ for (i=0; i < (MagickOffsetType) length; i+=count)
+ {
+ count=(MagickOffsetType) send(file,message+i,(size_t) MagickMin(length-i,
+ (MagickSizeType) SSIZE_MAX),MSG_NOSIGNAL);
+ if (count <= 0)
+ {
+ count=0;
+ if (errno != EINTR)
+ break;
+ }
+ }
+ return(i);
+}
+
+static MagickBooleanType OpenDistributeCache(SplayTreeInfo *registry,int file,
+ const size_t session_key,ExceptionInfo *exception)
+{
Image
*image;
MagickBooleanType
status;
- register unsigned char
- *p;
+ MagickOffsetType
+ count;
- size_t
+ MagickSizeType
length;
- ssize_t
- count;
+ register unsigned char
+ *p;
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- exception=AcquireExceptionInfo();
+ /*
+ Open distributed pixel cache.
+ */
image=AcquireImage((ImageInfo *) NULL,exception);
- exception=DestroyExceptionInfo(exception);
if (image == (Image *) NULL)
return(MagickFalse);
- length=sizeof(image->columns)+sizeof(image->rows)+
- sizeof(image->number_channels);
- count=recv(file,buffer,length,0);
- if (count != (ssize_t) length)
+ length=sizeof(image->storage_class)+sizeof(image->colorspace)+
+ sizeof(image->alpha_trait)+sizeof(image->read_mask)+
+ sizeof(image->write_mask)+sizeof(image->columns)+sizeof(image->rows)+
+ sizeof(image->number_channels)+MaxPixelChannels*sizeof(*image->channel_map)+
+ sizeof(image->metacontent_extent);
+ count=dpc_read(file,length,message);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- p=buffer;
+ /*
+ Deserialize the image attributes.
+ */
+ p=message;
+ (void) memcpy(&image->storage_class,p,sizeof(image->storage_class));
+ p+=sizeof(image->storage_class);
+ (void) memcpy(&image->colorspace,p,sizeof(image->colorspace));
+ p+=sizeof(image->colorspace);
+ (void) memcpy(&image->alpha_trait,p,sizeof(image->alpha_trait));
+ p+=sizeof(image->alpha_trait);
+ (void) memcpy(&image->read_mask,p,sizeof(image->read_mask));
+ p+=sizeof(image->read_mask);
+ (void) memcpy(&image->write_mask,p,sizeof(image->write_mask));
+ p+=sizeof(image->write_mask);
(void) memcpy(&image->columns,p,sizeof(image->columns));
p+=sizeof(image->columns);
(void) memcpy(&image->rows,p,sizeof(image->rows));
p+=sizeof(image->rows);
(void) memcpy(&image->number_channels,p,sizeof(image->number_channels));
p+=sizeof(image->number_channels);
- status=AddValueToSplayTree(image_registry,(const void *) session_key,image);
+ (void) memcpy(image->channel_map,p,MaxPixelChannels*
+ sizeof(*image->channel_map));
+ p+=MaxPixelChannels*sizeof(*image->channel_map);
+ (void) memcpy(&image->metacontent_extent,p,sizeof(image->metacontent_extent));
+ p+=sizeof(image->metacontent_extent);
+ if (SyncImagePixelCache(image,exception) == MagickFalse)
+ return(MagickFalse);
+ status=AddValueToSplayTree(registry,(const void *) session_key,image);
return(status);
}
-static MagickBooleanType ReadDistributeCacheMetacontent(
- SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+static MagickBooleanType ReadDistributeCacheMetacontent(SplayTreeInfo *registry,
+ int file,const size_t session_key,ExceptionInfo *exception)
{
const unsigned char
*metacontent;
- ExceptionInfo
- *exception;
-
Image
*image;
+ MagickOffsetType
+ count;
+
+ MagickSizeType
+ length;
+
RectangleInfo
region;
register unsigned char
*q;
- size_t
- length;
-
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
- session_key);
+ /*
+ Read distributed pixel cache metacontent.
+ */
+ image=(Image *) GetValueFromSplayTree(registry,(const void *) session_key);
if (image == (Image *) NULL)
return(MagickFalse);
length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
sizeof(region.y)+sizeof(length);
- count=recv(file,buffer,length,0);
- if (count != (ssize_t) length)
+ count=dpc_read(file,length,message);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- q=buffer;
+ q=message;
(void) memcpy(®ion.width,q,sizeof(region.width));
q+=sizeof(region.width);
(void) memcpy(®ion.height,q,sizeof(region.height));
- q+=sizeof(region.width);
+ q+=sizeof(region.height);
(void) memcpy(®ion.x,q,sizeof(region.x));
- q+=sizeof(region.width);
+ q+=sizeof(region.x);
(void) memcpy(®ion.y,q,sizeof(region.y));
- q+=sizeof(region.width);
+ q+=sizeof(region.y);
(void) memcpy(&length,q,sizeof(length));
q+=sizeof(length);
- exception=AcquireExceptionInfo();
p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
exception);
- exception=DestroyExceptionInfo(exception);
if (p == (const Quantum *) NULL)
return(MagickFalse);
- metacontent=GetVirtualMetacontent(image);
- count=send(file,metacontent,length,0);
- if (count != (ssize_t) length)
+ metacontent=(const unsigned char *) GetVirtualMetacontent(image);
+ count=dpc_send(file,length,metacontent);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
return(MagickTrue);
}
-static MagickBooleanType ReadDistributeCachePixels(
- SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+static MagickBooleanType ReadDistributeCachePixels(SplayTreeInfo *registry,
+ int file,const size_t session_key,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
Image
*image;
+ MagickOffsetType
+ count;
+
+ MagickSizeType
+ length;
+
RectangleInfo
region;
register unsigned char
*q;
- size_t
- length;
-
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
- session_key);
+ /*
+ Read distributed pixel cache pixels.
+ */
+ image=(Image *) GetValueFromSplayTree(registry,(const void *) session_key);
if (image == (Image *) NULL)
return(MagickFalse);
length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
sizeof(region.y)+sizeof(length);
- count=recv(file,buffer,length,0);
- if (count != (ssize_t) length)
+ count=dpc_read(file,length,message);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- q=buffer;
+ q=message;
(void) memcpy(®ion.width,q,sizeof(region.width));
q+=sizeof(region.width);
(void) memcpy(®ion.height,q,sizeof(region.height));
- q+=sizeof(region.width);
+ q+=sizeof(region.height);
(void) memcpy(®ion.x,q,sizeof(region.x));
- q+=sizeof(region.width);
+ q+=sizeof(region.x);
(void) memcpy(®ion.y,q,sizeof(region.y));
- q+=sizeof(region.width);
+ q+=sizeof(region.y);
(void) memcpy(&length,q,sizeof(length));
q+=sizeof(length);
- exception=AcquireExceptionInfo();
p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
exception);
- exception=DestroyExceptionInfo(exception);
if (p == (const Quantum *) NULL)
return(MagickFalse);
- count=send(file,p,length,0);
- if (count != (ssize_t) length)
+ count=dpc_send(file,length,(unsigned char *) p);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
return(MagickTrue);
}
-static MagickBooleanType WriteDistributeCacheMetacontent(
- SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+static void *RelinquishImageRegistry(void *image)
{
- ExceptionInfo
- *exception;
+ return((void *) DestroyImageList((Image *) image));
+}
+static MagickBooleanType WriteDistributeCacheMetacontent(
+ SplayTreeInfo *registry,int file,const size_t session_key,
+ ExceptionInfo *exception)
+{
Image
*image;
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
+
+ MagickSizeType
+ length;
RectangleInfo
region;
register unsigned char
*p;
- size_t
- length;
-
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent],
+ message[MaxTextExtent],
*metacontent;
- image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
- session_key);
+ /*
+ Write distributed pixel cache metacontent.
+ */
+ image=(Image *) GetValueFromSplayTree(registry,(const void *) session_key);
if (image == (Image *) NULL)
return(MagickFalse);
length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
sizeof(region.y)+sizeof(length);
- count=recv(file,buffer,length,0);
- if (count != (ssize_t) length)
+ count=dpc_read(file,length,message);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- p=buffer;
+ p=message;
(void) memcpy(®ion.width,p,sizeof(region.width));
p+=sizeof(region.width);
(void) memcpy(®ion.height,p,sizeof(region.height));
- p+=sizeof(region.width);
+ p+=sizeof(region.height);
(void) memcpy(®ion.x,p,sizeof(region.x));
- p+=sizeof(region.width);
+ p+=sizeof(region.x);
(void) memcpy(®ion.y,p,sizeof(region.y));
- p+=sizeof(region.width);
+ p+=sizeof(region.y);
(void) memcpy(&length,p,sizeof(length));
p+=sizeof(length);
- exception=AcquireExceptionInfo();
q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
exception);
- exception=DestroyExceptionInfo(exception);
if (q == (Quantum *) NULL)
return(MagickFalse);
- metacontent=GetAuthenticMetacontent(image);
- count=recv(file,metacontent,length,0);
- if (count != (ssize_t) length)
+ metacontent=(unsigned char *) GetAuthenticMetacontent(image);
+ count=dpc_read(file,length,metacontent);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- status=SyncAuthenticPixels(image,exception);
- return(status);
+ return(SyncAuthenticPixels(image,exception));
}
-static MagickBooleanType WriteDistributeCachePixels(
- SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+static MagickBooleanType WriteDistributeCachePixels(SplayTreeInfo *registry,
+ int file,const size_t session_key,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
Image
*image;
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
+
+ MagickSizeType
+ length;
RectangleInfo
region;
register unsigned char
*p;
- size_t
- length;
-
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
- session_key);
+ /*
+ Write distributed pixel cache pixels.
+ */
+ image=(Image *) GetValueFromSplayTree(registry,(const void *) session_key);
if (image == (Image *) NULL)
return(MagickFalse);
length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
sizeof(region.y)+sizeof(length);
- count=recv(file,buffer,length,0);
- if (count != (ssize_t) length)
+ count=dpc_read(file,length,message);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- p=buffer;
+ p=message;
(void) memcpy(®ion.width,p,sizeof(region.width));
p+=sizeof(region.width);
(void) memcpy(®ion.height,p,sizeof(region.height));
- p+=sizeof(region.width);
+ p+=sizeof(region.height);
(void) memcpy(®ion.x,p,sizeof(region.x));
- p+=sizeof(region.width);
+ p+=sizeof(region.x);
(void) memcpy(®ion.y,p,sizeof(region.y));
- p+=sizeof(region.width);
+ p+=sizeof(region.y);
(void) memcpy(&length,p,sizeof(length));
p+=sizeof(length);
- exception=AcquireExceptionInfo();
q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
exception);
- exception=DestroyExceptionInfo(exception);
if (q == (Quantum *) NULL)
return(MagickFalse);
- count=recv(file,q,length,0);
- if (count != (ssize_t) length)
+ count=dpc_read(file,length,(unsigned char *) q);
+ if (count != (MagickOffsetType) length)
return(MagickFalse);
- status=SyncAuthenticPixels(image,exception);
- return(status);
+ return(SyncAuthenticPixels(image,exception));
}
-static void *DistributePixelCacheClient(void *client_info)
+static void *DistributePixelCacheClient(void *socket)
{
-#if defined(MAGICKCORE_THREAD_SUPPORT)
const char
*shared_secret;
+ ExceptionInfo
+ *exception;
+
int
client_socket;
MagickBooleanType
status;
- MagickSizeType
- key,
- session_key;
+ MagickOffsetType
+ count;
+
+ register unsigned char
+ *p;
RandomInfo
*random_info;
- SplayTreeInfo
- *image_registry;
+ size_t
+ key,
+ session_key;
- ssize_t
- count;
+ SplayTreeInfo
+ *registry;
StringInfo
*secret;
unsigned char
command,
- session[MaxTextExtent];
+ session[2*MaxTextExtent];
/*
- Deallocate thread resources on return.
- */
- pthread_detach(pthread_self());
- client_socket=((ClientInfo *) client_info)->socket;
- client_info=RelinquishMagickMemory(client_info);
- /*
- Generate session key.
+ Distributed pixel cache client.
*/
shared_secret=GetPolicyValue("shared-secret");
if (shared_secret == (const char *) NULL)
ThrowFatalException(CacheFatalError,"shared secret expected");
- (void) CopyMagickString((char *) session,shared_secret,MaxTextExtent-
- DPCSessionKeyLength);
+ p=session;
+ (void) CopyMagickString((char *) p,shared_secret,MaxTextExtent);
+ p+=strlen(shared_secret);
random_info=AcquireRandomInfo();
secret=GetRandomKey(random_info,DPCSessionKeyLength);
- (void) memcpy(session+strlen(shared_secret),GetStringInfoDatum(secret),
- DPCSessionKeyLength);
- session_key=CRC64(session,strlen(shared_secret)+DPCSessionKeyLength);
+ (void) memcpy(p,GetStringInfoDatum(secret),DPCSessionKeyLength);
+ session_key=GetMagickSignature(secret);
random_info=DestroyRandomInfo(random_info);
- image_registry=NewSplayTree((int (*)(const void *,const void *)) NULL,
- (void *(*)(void *)) NULL,(void *(*)(void *)) NULL);
- count=send(client_socket,GetStringInfoDatum(secret),DPCSessionKeyLength,0);
+ exception=AcquireExceptionInfo();
+ registry=NewSplayTree((int (*)(const void *,const void *)) NULL,
+ (void *(*)(void *)) NULL,RelinquishImageRegistry);
+ client_socket=(*(int *) socket);
+ count=dpc_send(client_socket,DPCSessionKeyLength,GetStringInfoDatum(secret));
secret=DestroyStringInfo(secret);
for ( ; ; )
{
- count=recv(client_socket,&command,1,0);
+ count=dpc_read(client_socket,1,(unsigned char *) &command);
if (count <= 0)
break;
- count=recv(client_socket,&key,sizeof(key),0);
- if ((count != (ssize_t) sizeof(key)) && (key != session_key))
+ count=dpc_read(client_socket,sizeof(key),(unsigned char *) &key);
+ if ((count != (MagickOffsetType) sizeof(key)) || (key != session_key))
break;
status=MagickFalse;
switch (command)
{
case 'o':
{
- status=OpenDistributeCache(image_registry,client_socket,session_key);
+ status=OpenDistributeCache(registry,client_socket,session_key,
+ exception);
+ count=dpc_send(client_socket,sizeof(status),(unsigned char *) &status);
break;
}
case 'r':
{
- status=ReadDistributeCachePixels(image_registry,client_socket,
- session_key);
+ status=ReadDistributeCachePixels(registry,client_socket,session_key,
+ exception);
break;
}
case 'R':
{
- status=ReadDistributeCacheMetacontent(image_registry,client_socket,
- session_key);
+ status=ReadDistributeCacheMetacontent(registry,client_socket,
+ session_key,exception);
break;
}
case 'w':
{
- status=WriteDistributeCachePixels(image_registry,client_socket,
- session_key);
+ status=WriteDistributeCachePixels(registry,client_socket,session_key,
+ exception);
break;
}
case 'W':
{
- status=WriteDistributeCacheMetacontent(image_registry,client_socket,
- session_key);
+ status=WriteDistributeCacheMetacontent(registry,client_socket,
+ session_key,exception);
break;
}
case 'd':
{
- status=DestroyDistributeCache(image_registry,client_socket,session_key);
+ status=DestroyDistributeCache(registry,client_socket,session_key);
break;
}
default:
break;
}
- count=send(client_socket,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
+ if (status == MagickFalse)
break;
if (command == 'd')
break;
}
+ count=dpc_send(client_socket,sizeof(status),(unsigned char *) &status);
(void) close(client_socket);
- image_registry=DestroySplayTree(image_registry);
+ exception=DestroyExceptionInfo(exception);
+ registry=DestroySplayTree(registry);
return((void *) NULL);
-#else
- ThrowFatalException(MissingDelegateError,"POSIX threads");
-#endif
}
-#endif
-MagickExport void DistributePixelCacheServer(const size_t port,
+MagickExport void DistributePixelCacheServer(const int port,
ExceptionInfo *exception)
{
#if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)
+ char
+ service[MaxTextExtent];
+
int
server_socket,
status;
attributes;
pthread_t
- id;
+ threads;
+
+ register struct addrinfo
+ *p;
+
+ struct addrinfo
+ hint,
+ *result;
struct sockaddr_in
address;
/*
Launch distributed pixel cache server.
*/
- server_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
- address.sin_family=AF_INET;
- address.sin_port=htons(port);
- address.sin_addr.s_addr=htonl(INADDR_ANY);
- status=bind(server_socket,(struct sockaddr *) &address,(socklen_t)
- sizeof(address));
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ (void) ResetMagickMemory(&hint,0,sizeof(hint));
+ hint.ai_family=AF_INET;
+ hint.ai_socktype=SOCK_STREAM;
+ hint.ai_flags=AI_PASSIVE;
+ (void) FormatLocaleString(service,MaxTextExtent,"%d",port);
+ status=getaddrinfo((const char *) NULL,service,&hint,&result);
if (status != 0)
+ ThrowFatalException(CacheFatalError,"UnableToListen");
+ server_socket=0;
+ for (p=result; p != (struct addrinfo *) NULL; p=p->ai_next)
+ {
+ int
+ one;
+
+ server_socket=socket(p->ai_family,p->ai_socktype,p->ai_protocol);
+ if (server_socket == -1)
+ continue;
+ one=1;
+ status=setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&one,(socklen_t)
+ sizeof(one));
+ if (status == -1)
+ {
+ (void) close(server_socket);
+ continue;
+ }
+ status=bind(server_socket,p->ai_addr,p->ai_addrlen);
+ if (status == -1)
+ {
+ (void) close(server_socket);
+ continue;
+ }
+ break;
+ }
+ if (p == (struct addrinfo *) NULL)
ThrowFatalException(CacheFatalError,"UnableToBind");
+ freeaddrinfo(result);
status=listen(server_socket,DPCPendingConnections);
if (status != 0)
ThrowFatalException(CacheFatalError,"UnableToListen");
pthread_attr_init(&attributes);
for ( ; ; )
{
- ClientInfo
- *client_info;
-
int
client_socket;
client_socket=accept(server_socket,(struct sockaddr *) &address,&length);
if (client_socket == -1)
ThrowFatalException(CacheFatalError,"UnableToEstablishConnection");
- client_info=(ClientInfo *) AcquireMagickMemory(sizeof(*client_info));
- if (client_info == (ClientInfo *) NULL)
- ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
- client_info->socket=client_socket;
- status=pthread_create(&id,&attributes,DistributePixelCacheClient,(void *)
- client_info);
+ status=pthread_create(&threads,&attributes,DistributePixelCacheClient,
+ (void *) &client_socket);
if (status == -1)
ThrowFatalException(CacheFatalError,"UnableToCreateClientThread");
}
%
% The format of the GetDistributeCacheFile method is:
%
-% int GetDistributeCacheFile(
-% const DistributeCacheInfo *distribute_cache_info)
+% int GetDistributeCacheFile(const DistributeCacheInfo *server_info)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
*/
-MagickPrivate int GetDistributeCacheFile(
- const DistributeCacheInfo *distribute_cache_info)
+MagickPrivate int GetDistributeCacheFile(const DistributeCacheInfo *server_info)
{
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
- return(distribute_cache_info->file);
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
+ return(server_info->file);
}
\f
/*
% The format of the GetDistributeCacheHostname method is:
%
% const char *GetDistributeCacheHostname(
-% const DistributeCacheInfo *distribute_cache_info)
+% const DistributeCacheInfo *server_info)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
*/
MagickPrivate const char *GetDistributeCacheHostname(
- const DistributeCacheInfo *distribute_cache_info)
+ const DistributeCacheInfo *server_info)
{
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
- return(distribute_cache_info->hostname);
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
+ return(server_info->hostname);
}
\f
/*
%
% The format of the GetDistributeCachePort method is:
%
-% int GetDistributeCachePort(
-% const DistributeCacheInfo *distribute_cache_info)
+% int GetDistributeCachePort(const DistributeCacheInfo *server_info)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
*/
-MagickPrivate int GetDistributeCachePort(
- const DistributeCacheInfo *distribute_cache_info)
+MagickPrivate int GetDistributeCachePort(const DistributeCacheInfo *server_info)
{
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
- return(distribute_cache_info->port);
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
+ return(server_info->port);
}
\f
/*
% The format of the OpenDistributePixelCache method is:
%
% MagickBooleanType *OpenDistributePixelCache(
-% DistributeCacheInfo *distribute_cache_info,Image *image)
+% DistributeCacheInfo *server_info,Image *image)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
% o image: the image.
%
*/
MagickPrivate MagickBooleanType OpenDistributePixelCache(
- DistributeCacheInfo *distribute_cache_info,Image *image)
+ DistributeCacheInfo *server_info,Image *image)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
MagickBooleanType
status;
+ MagickOffsetType
+ count;
+
register unsigned char
*p;
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
+ /*
+ Open distributed pixel cache.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- p=buffer;
+ p=message;
*p++='o'; /* open */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
+ /*
+ Serialize image attributes (see ValidatePixelCacheMorphology()).
+ */
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
+ (void) memcpy(p,&image->storage_class,sizeof(image->storage_class));
+ p+=sizeof(image->storage_class);
+ (void) memcpy(p,&image->colorspace,sizeof(image->colorspace));
+ p+=sizeof(image->colorspace);
+ (void) memcpy(p,&image->alpha_trait,sizeof(image->alpha_trait));
+ p+=sizeof(image->alpha_trait);
+ (void) memcpy(p,&image->read_mask,sizeof(image->read_mask));
+ p+=sizeof(image->read_mask);
+ (void) memcpy(p,&image->write_mask,sizeof(image->write_mask));
+ p+=sizeof(image->write_mask);
(void) memcpy(p,&image->columns,sizeof(image->columns));
p+=sizeof(image->columns);
(void) memcpy(p,&image->rows,sizeof(image->rows));
p+=sizeof(image->rows);
(void) memcpy(p,&image->number_channels,sizeof(image->number_channels));
p+=sizeof(image->number_channels);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
+ (void) memcpy(p,image->channel_map,MaxPixelChannels*
+ sizeof(*image->channel_map));
+ p+=MaxPixelChannels*sizeof(*image->channel_map);
+ (void) memcpy(p,&image->metacontent_extent,sizeof(image->metacontent_extent));
+ p+=sizeof(image->metacontent_extent);
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
return(MagickFalse);
- count=recv(distribute_cache_info->file,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
+ status=MagickFalse;
+ count=dpc_read(server_info->file,sizeof(status),(unsigned char *) &status);
+ if (count != (MagickOffsetType) sizeof(status))
return(MagickFalse);
- return(MagickTrue);
-#else
- return(MagickFalse);
-#endif
+ return(status);
}
\f
/*
%
% The format of the ReadDistributePixelCacheMetacontents method is:
%
-% MagickBooleanType *ReadDistributePixelCacheMetacontents(
-% DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+% MagickOffsetType ReadDistributePixelCacheMetacontents(
+% DistributeCacheInfo *server_info,const RectangleInfo *region,
% const MagickSizeType length,unsigned char *metacontent)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
% o image: the image.
%
% o metacontent: read these metacontent from the pixel cache.
%
*/
-MagickPrivate MagickBooleanType ReadDistributePixelCacheMetacontent(
- DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+MagickPrivate MagickOffsetType ReadDistributePixelCacheMetacontent(
+ DistributeCacheInfo *server_info,const RectangleInfo *region,
const MagickSizeType length,unsigned char *metacontent)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
register unsigned char
*p;
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
+ /*
+ Read distributed pixel cache metacontent.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
assert(region != (RectangleInfo *) NULL);
assert(metacontent != (unsigned char *) NULL);
- assert(length == ((size_t) length));
- p=buffer;
- *p++='R'; /* read */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
+ if (length > (MagickSizeType) SSIZE_MAX)
+ return(-1);
+ p=message;
+ *p++='R';
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
(void) memcpy(p,®ion->width,sizeof(region->width));
p+=sizeof(region->width);
(void) memcpy(p,®ion->height,sizeof(region->height));
p+=sizeof(region->y);
(void) memcpy(p,&length,sizeof(length));
p+=sizeof(length);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
- return(MagickFalse);
- count=recv(distribute_cache_info->file,(unsigned char *) metacontent,(size_t)
- length,0);
- if (count != (ssize_t) length)
- return(MagickFalse);
- count=recv(distribute_cache_info->file,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
- return(MagickFalse);
- return(status != 0 ? MagickTrue : MagickFalse);
-#else
- return(MagickFalse);
-#endif
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
+ return(-1);
+ return(dpc_read(server_info->file,length,metacontent));
}
\f
/*
%
% The format of the ReadDistributePixelCachePixels method is:
%
-% MagickBooleanType *ReadDistributePixelCachePixels(
-% DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-% const MagickSizeType length,unsigned char *pixels)
+% MagickOffsetType ReadDistributePixelCachePixels(
+% DistributeCacheInfo *server_info,const RectangleInfo *region,
+% const MagickSizeType length,unsigned char *restrict pixels)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
% o image: the image.
%
% o pixels: read these pixels from the pixel cache.
%
*/
-MagickPrivate MagickBooleanType ReadDistributePixelCachePixels(
- DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
- const MagickSizeType length,unsigned char *pixels)
+MagickPrivate MagickOffsetType ReadDistributePixelCachePixels(
+ DistributeCacheInfo *server_info,const RectangleInfo *region,
+ const MagickSizeType length,unsigned char *restrict pixels)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
register unsigned char
*p;
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
+ /*
+ Read distributed pixel cache pixels.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
assert(region != (RectangleInfo *) NULL);
assert(pixels != (unsigned char *) NULL);
- assert(length == ((size_t) length));
- p=buffer;
- *p++='r'; /* read */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
+ if (length > (MagickSizeType) SSIZE_MAX)
+ return(-1);
+ p=message;
+ *p++='r';
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
(void) memcpy(p,®ion->width,sizeof(region->width));
p+=sizeof(region->width);
(void) memcpy(p,®ion->height,sizeof(region->height));
p+=sizeof(region->y);
(void) memcpy(p,&length,sizeof(length));
p+=sizeof(length);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
- return(MagickFalse);
- count=recv(distribute_cache_info->file,(unsigned char *) pixels,(size_t)
- length,0);
- if (count != (ssize_t) length)
- return(MagickFalse);
- count=recv(distribute_cache_info->file,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
- return(MagickFalse);
- return(status != 0 ? MagickTrue : MagickFalse);
-#else
- return(MagickFalse);
-#endif
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
+ return(-1);
+ return(dpc_read(server_info->file,length,pixels));
}
\f
/*
% The format of the RelinquishDistributePixelCache method is:
%
% MagickBooleanType RelinquishDistributePixelCache(
-% DistributeCacheInfo *distribute_cache_info)
+% DistributeCacheInfo *server_info)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
*/
MagickPrivate MagickBooleanType RelinquishDistributePixelCache(
- DistributeCacheInfo *distribute_cache_info)
+ DistributeCacheInfo *server_info)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
- register unsigned char
- *p;
+ MagickBooleanType
+ status;
- ssize_t
+ MagickOffsetType
count;
+ register unsigned char
+ *p;
+
unsigned char
- buffer[MaxTextExtent];
-
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
- p=buffer;
- *p++='d'; /* delete */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
+ message[MaxTextExtent];
+
+ /*
+ Delete distributed pixel cache.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
+ p=message;
+ *p++='d';
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
return(MagickFalse);
- return(MagickTrue);
-#else
- return(MagickFalse);
-#endif
+ count=dpc_read(server_info->file,sizeof(status),(unsigned char *) &status);
+ if (count != (MagickOffsetType) sizeof(status))
+ return(MagickFalse);
+ return(status);
}
\f
/*
% WriteDistributePixelCacheMetacontents() writes image metacontent to the
% specified region of the distributed pixel cache.
%
-%
% The format of the WriteDistributePixelCacheMetacontents method is:
%
-% MagickBooleanType *WriteDistributePixelCacheMetacontents(
-% DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+% MagickOffsetType WriteDistributePixelCacheMetacontents(
+% DistributeCacheInfo *server_info,const RectangleInfo *region,
% const MagickSizeType length,const unsigned char *metacontent)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
% o image: the image.
%
% o metacontent: write these metacontent to the pixel cache.
%
*/
-MagickPrivate MagickBooleanType WriteDistributePixelCacheMetacontent(
- DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+MagickPrivate MagickOffsetType WriteDistributePixelCacheMetacontent(
+ DistributeCacheInfo *server_info,const RectangleInfo *region,
const MagickSizeType length,const unsigned char *metacontent)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
register unsigned char
*p;
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
+ /*
+ Write distributed pixel cache metacontent.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
assert(region != (RectangleInfo *) NULL);
assert(metacontent != (unsigned char *) NULL);
- assert(length == ((size_t) length));
- p=buffer;
- *p++='W'; /* write */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
+ if (length > (MagickSizeType) SSIZE_MAX)
+ return(-1);
+ p=message;
+ *p++='W';
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
(void) memcpy(p,®ion->width,sizeof(region->width));
p+=sizeof(region->width);
(void) memcpy(p,®ion->height,sizeof(region->height));
p+=sizeof(region->y);
(void) memcpy(p,&length,sizeof(length));
p+=sizeof(length);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
- return(MagickFalse);
- count=send(distribute_cache_info->file,(unsigned char *) metacontent,(size_t)
- length,0);
- if (count != (ssize_t) length)
- return(MagickFalse);
- count=recv(distribute_cache_info->file,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
- return(MagickFalse);
- return(status != 0 ? MagickTrue : MagickFalse);
-#else
- return(MagickFalse);
-#endif
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
+ return(-1);
+ return(dpc_send(server_info->file,length,metacontent));
}
\f
/*
% WriteDistributePixelCachePixels() writes image pixels to the specified
% region of the distributed pixel cache.
%
-%
% The format of the WriteDistributePixelCachePixels method is:
%
-% MagickBooleanType *WriteDistributePixelCachePixels(
-% DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-% const MagickSizeType length,const unsigned char *pixels)
+% MagickBooleanType WriteDistributePixelCachePixels(
+% DistributeCacheInfo *server_info,const RectangleInfo *region,
+% const MagickSizeType length,const unsigned char *restrict pixels)
%
% A description of each parameter follows:
%
-% o distribute_cache_info: the distributed cache info.
+% o server_info: the distributed cache info.
%
% o image: the image.
%
% o pixels: write these pixels to the pixel cache.
%
*/
-MagickPrivate MagickBooleanType WriteDistributePixelCachePixels(
- DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
- const MagickSizeType length,const unsigned char *pixels)
+MagickPrivate MagickOffsetType WriteDistributePixelCachePixels(
+ DistributeCacheInfo *server_info,const RectangleInfo *region,
+ const MagickSizeType length,const unsigned char *restrict pixels)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
- MagickBooleanType
- status;
+ MagickOffsetType
+ count;
register unsigned char
*p;
- ssize_t
- count;
-
unsigned char
- buffer[MaxTextExtent];
+ message[MaxTextExtent];
- assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
- assert(distribute_cache_info->signature == MagickSignature);
+ /*
+ Write distributed pixel cache pixels.
+ */
+ assert(server_info != (DistributeCacheInfo *) NULL);
+ assert(server_info->signature == MagickSignature);
assert(region != (RectangleInfo *) NULL);
assert(pixels != (const unsigned char *) NULL);
- assert(length == ((size_t) length));
- p=buffer;
- *p++='w'; /* write */
- (void) memcpy(p,&distribute_cache_info->session_key,
- sizeof(distribute_cache_info->session_key));
- p+=sizeof(distribute_cache_info->session_key);
+ if (length > (MagickSizeType) SSIZE_MAX)
+ return(-1);
+ p=message;
+ *p++='w';
+ (void) memcpy(p,&server_info->session_key,sizeof(server_info->session_key));
+ p+=sizeof(server_info->session_key);
(void) memcpy(p,®ion->width,sizeof(region->width));
p+=sizeof(region->width);
(void) memcpy(p,®ion->height,sizeof(region->height));
p+=sizeof(region->y);
(void) memcpy(p,&length,sizeof(length));
p+=sizeof(length);
- count=send(distribute_cache_info->file,buffer,p-buffer,0);
- if (count != (ssize_t) (p-buffer))
- return(MagickFalse);
- count=send(distribute_cache_info->file,(unsigned char *) pixels,(size_t)
- length,0);
- if (count != (ssize_t) length)
- return(MagickFalse);
- count=recv(distribute_cache_info->file,&status,sizeof(status),0);
- if (count != (ssize_t) sizeof(status))
- return(MagickFalse);
- return(status != 0 ? MagickTrue : MagickFalse);
-#else
- return(MagickFalse);
-#endif
+ count=dpc_send(server_info->file,p-message,message);
+ if (count != (MagickOffsetType) (p-message))
+ return(-1);
+ return(dpc_send(server_info->file,length,pixels));
}
projects / imagemagick / blobdiff