% 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/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/string_.h"
#include "MagickCore/string-private.h"
#include "MagickCore/version.h"
-#if defined(MAGICKCORE_HAVE_SOCKET)
+#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
/*
%
*/
-static size_t CRC64(const unsigned char *message,const MagickSizeType length)
-{
- register MagickOffsetType
- i;
-
- size_t
- crc;
-
- static MagickBooleanType
- crc_initial = MagickFalse;
-
- static size_t
- crc_xor[256];
-
- /*
- Generate a 64-bit cyclic redundancy check for the message.
- */
- if (crc_initial == MagickFalse)
- {
- size_t
- alpha;
-
- for (i=0; i < 256; i++)
- {
- register MagickOffsetType
- j;
-
- alpha=(size_t) i;
- for (j=0; j < 8; j++)
- {
- if ((alpha & 0x01) == 0)
- alpha>>=1;
- else
- alpha=(size_t) ((alpha >> 1) ^
- MagickULLConstant(0xd800000000000000));
- }
- crc_xor[i]=alpha;
- }
- crc_initial=MagickTrue;
- }
- crc=0;
- for (i=0; i < (MagickOffsetType) length; i++)
- crc=crc_xor[(crc ^ message[i]) & 0xff] ^ (crc >> 8);
- return(crc);
-}
-
static inline MagickSizeType MagickMin(const MagickSizeType x,
const MagickSizeType y)
{
ssize_t
count;
+#if !defined(MAGICKCORE_HAVE_SOCKET) || !defined(MAGICKCORE_THREAD_SUPPORT)
+ magick_unreferenced(file);
+ magick_unreferenced(message);
+#endif
+
count=0;
for (i=0; i < (MagickOffsetType) length; i+=count)
{
static int ConnectPixelCacheServer(const char *hostname,const int port,
size_t *session_key,ExceptionInfo *exception)
{
-#if defined(MAGICKCORE_HAVE_SOCKET)
+#if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)
char
service[MaxTextExtent];
client_socket,
status;
- register unsigned char
- *p;
-
ssize_t
count;
*result;
unsigned char
- secret[MaxTextExtent],
- session[2*MaxTextExtent];
+ secret[MaxTextExtent];
/*
Connect to distributed pixel cache and get session key.
"DistributedPixelCache","'%s'","shared secret expected");
return(-1);
}
- p=session;
- (void) CopyMagickString((char *) p,shared_secret,MaxTextExtent);
- p+=strlen(shared_secret);
(void) ResetMagickMemory(&hint,0,sizeof(hint));
hint.ai_family=AF_INET;
hint.ai_socktype=SOCK_STREAM;
result->ai_protocol);
if (client_socket == -1)
{
+ (void) close(client_socket);
(void) ThrowMagickException(exception,GetMagickModule(),CacheError,
"DistributedPixelCache","'%s'",hostname);
return(-1);
count=recv(client_socket,secret,MaxTextExtent,0);
if (count != -1)
{
- size_t
- signature;
-
- (void) memcpy(p,secret,(size_t) count);
- p+=count;
- signature=MagickLibVersion;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- signature=MAGICKCORE_QUANTUM_DEPTH;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- signature=MAGICKCORE_HDRI_ENABLE;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- *session_key=CRC64(session,p-session);
+ 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=DestroyString(hostname);
if (server_info->file == -1)
server_info=DestroyDistributeCacheInfo(server_info);
+ server_info->debug=IsEventLogging();
return(server_info);
}
\f
*/
static MagickBooleanType DestroyDistributeCache(SplayTreeInfo *registry,
- int file,const size_t session_key)
+ int magick_unused(file),const size_t session_key)
{
/*
Destroy distributed pixel cache.
*/
+ magick_unreferenced(file);
return(DeleteNodeFromSplayTree(registry,(const void *) session_key));
}
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.
*/
return(i);
}
-static MagickBooleanType OpenDistributeCache(SplayTreeInfo *registry,
- int file,const size_t session_key,ExceptionInfo *exception)
+static MagickBooleanType OpenDistributeCache(SplayTreeInfo *registry,int file,
+ const size_t session_key,ExceptionInfo *exception)
{
Image
*image;
if (image == (Image *) NULL)
return(MagickFalse);
length=sizeof(image->storage_class)+sizeof(image->colorspace)+
- sizeof(image->alpha_trait)+sizeof(image->mask)+sizeof(image->columns)+
- sizeof(image->rows)+sizeof(image->number_channels)+MaxPixelChannels*
- sizeof(*image->channel_map)+sizeof(image->metacontent_extent);
+ 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+=sizeof(image->colorspace);
(void) memcpy(&image->alpha_trait,p,sizeof(image->alpha_trait));
p+=sizeof(image->alpha_trait);
- (void) memcpy(&image->mask,p,sizeof(image->mask));
- p+=sizeof(image->mask);
+ (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));
exception);
if (p == (const Quantum *) NULL)
return(MagickFalse);
- metacontent=GetVirtualMetacontent(image);
+ metacontent=(const unsigned char *) GetVirtualMetacontent(image);
count=dpc_send(file,length,metacontent);
if (count != (MagickOffsetType) length)
return(MagickFalse);
exception);
if (q == (Quantum *) NULL)
return(MagickFalse);
- metacontent=GetAuthenticMetacontent(image);
+ metacontent=(unsigned char *) GetAuthenticMetacontent(image);
count=dpc_read(file,length,metacontent);
if (count != (MagickOffsetType) length)
return(MagickFalse);
size_t
key,
- session_key,
- signature;
+ session_key;
SplayTreeInfo
*registry;
random_info=AcquireRandomInfo();
secret=GetRandomKey(random_info,DPCSessionKeyLength);
(void) memcpy(p,GetStringInfoDatum(secret),DPCSessionKeyLength);
- p+=DPCSessionKeyLength;
- signature=MagickLibVersion;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- signature=MAGICKCORE_QUANTUM_DEPTH;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- signature=MAGICKCORE_HDRI_ENABLE;
- (void) memcpy(p,&signature,sizeof(signature));
- p+=sizeof(signature);
- session_key=CRC64(session,p-session);
+ session_key=GetMagickSignature(secret);
random_info=DestroyRandomInfo(random_info);
exception=AcquireExceptionInfo();
registry=NewSplayTree((int (*)(const void *,const void *)) NULL,
/*
Launch distributed pixel cache server.
*/
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
(void) ResetMagickMemory(&hint,0,sizeof(hint));
hint.ai_family=AF_INET;
hint.ai_socktype=SOCK_STREAM;
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
status=setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&one,(socklen_t)
sizeof(one));
if (status == -1)
- continue;
+ {
+ (void) close(server_socket);
+ continue;
+ }
status=bind(server_socket,p->ai_addr,p->ai_addrlen);
if (status == -1)
{
- (void) close(status);
+ (void) close(server_socket);
continue;
}
break;
p+=sizeof(image->colorspace);
(void) memcpy(p,&image->alpha_trait,sizeof(image->alpha_trait));
p+=sizeof(image->alpha_trait);
- (void) memcpy(p,&image->mask,sizeof(image->mask));
- p+=sizeof(image->mask);
+ (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));
%
% MagickOffsetType ReadDistributePixelCachePixels(
% DistributeCacheInfo *server_info,const RectangleInfo *region,
-% const MagickSizeType length,unsigned char *pixels)
+% const MagickSizeType length,unsigned char *restrict pixels)
%
% A description of each parameter follows:
%
*/
MagickPrivate MagickOffsetType ReadDistributePixelCachePixels(
DistributeCacheInfo *server_info,const RectangleInfo *region,
- const MagickSizeType length,unsigned char *pixels)
+ const MagickSizeType length,unsigned char *restrict pixels)
{
MagickOffsetType
count;
%
% MagickBooleanType WriteDistributePixelCachePixels(
% DistributeCacheInfo *server_info,const RectangleInfo *region,
-% const MagickSizeType length,const unsigned char *pixels)
+% const MagickSizeType length,const unsigned char *restrict pixels)
%
% A description of each parameter follows:
%
*/
MagickPrivate MagickOffsetType WriteDistributePixelCachePixels(
DistributeCacheInfo *server_info,const RectangleInfo *region,
- const MagickSizeType length,const unsigned char *pixels)
+ const MagickSizeType length,const unsigned char *restrict pixels)
{
MagickOffsetType
count;
projects / imagemagick / blobdiff