/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%    DDDD    IIIII   SSSSS  TTTTT  RRRR   IIIII  BBBB   U   U  TTTTT  EEEEE   %

%    D   D     I     SS       T    R   R    I    B   B  U   U    T    E       %

%    D   D     I      SSS     T    RRRR     I    BBBB   U   U    T    EEE     %

%    D   D     I        SS    T    R R      I    B   B  U   U    T    E       %

%    DDDDA   IIIII   SSSSS    T    R  R   IIIII  BBBB    UUU     T    EEEEE   %

%                                                                             %

%                      CCCC   AAA    CCCC  H   H  EEEEE                       %

%                     C      A   A  C      H   H  E                           %

%                     C      AAAAA  C      HHHHH  EEE                         %

%                     C      A   A  C      H   H  E                           %

%                      CCCC  A   A   CCCC  H   H  EEEEE                       %

%                                                                             %

%                                                                             %

%                 MagickCore Distributed Pixel Cache Methods                  %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                                January 2013                                 %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 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  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

% A distributed pixel cache is an extension of the traditional pixel cache

% available on a single host.  The distributed pixel cache may span multiple

% servers so that it can grow in size and transactional capacity to support

% very large images.  Start up the pixel cache server on one or more machines.

% When you read or operate on an image and the local pixel cache resources are

% exhausted, ImageMagick contacts one or more of these remote pixel servers to

% store or retrieve pixels.

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/cache.h"

#include "MagickCore/cache-private.h"

#include "MagickCore/distribute-cache.h"

#include "MagickCore/distribute-cache-private.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/geometry.h"

#include "MagickCore/image.h"

#include "MagickCore/image-private.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"

#include "MagickCore/utility-private.h"

#include "MagickCore/version.h"

#include "MagickCore/version-private.h"

#define SOCKET_TYPE int

#undef MAGICKCORE_HAVE_DISTRIBUTE_CACHE

#if defined(MAGICKCORE_DPC_SUPPORT)

#if defined(MAGICKCORE_HAVE_SOCKET) && defined(MAGICKCORE_THREAD_SUPPORT)

#include <netinet/in.h>

#include <netdb.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#define CLOSE_SOCKET(socket) (void) close_utf8(socket)

#define HANDLER_RETURN_TYPE void *

#define HANDLER_RETURN_VALUE (void *) NULL

#define SOCKET_TYPE int

#define LENGTH_TYPE size_t

#define MAGICKCORE_HAVE_DISTRIBUTE_CACHE 1

#elif defined(_MSC_VER)

#define CLOSE_SOCKET(socket) (void) closesocket(socket)

#define HANDLER_RETURN_TYPE DWORD WINAPI

#define HANDLER_RETURN_VALUE 0

#define LENGTH_TYPE int

#define MAGICKCORE_HAVE_DISTRIBUTE_CACHE 1

#define MAGICKCORE_HAVE_WINSOCK2 1

#endif

#endif

/*

  Define declarations.

*/

#define DPCHostname  "127.0.0.1"

#define DPCMaxClientWorkers  128

#define DPCMaxUnauthenticatedClientWorkers  16

#define DPCPendingConnections  10

#define DPCPort  6668

#define DPCSessionKeyLength  16

#ifndef MSG_NOSIGNAL

#  define MSG_NOSIGNAL 0

#endif

/*

  Static declarations.

*/

#ifdef MAGICKCORE_HAVE_WINSOCK2

static SemaphoreInfo

  *winsock_semaphore = (SemaphoreInfo *) NULL;

static WSADATA

  *wsaData = (WSADATA*) NULL;

#endif

#if defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

static SemaphoreInfo

  *dpc_semaphore = (SemaphoreInfo *) NULL;

static char

  *dpc_shared_secret = (char *) NULL;

static size_t

  dpc_clients = 0,

  dpc_unauthenticated_clients = 0;

#endif

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   A c q u i r e D i s t r i b u t e C a c h e I n f o                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  AcquireDistributeCacheInfo() allocates the DistributeCacheInfo structure.

%

%  The format of the AcquireDistributeCacheInfo method is:

%

%      DistributeCacheInfo *AcquireDistributeCacheInfo(ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o exception: return any errors or warnings in this structure.

%

*/

#if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

static inline MagickOffsetType dpc_receive(SOCKET_TYPE magick_unused(file),

  const MagickSizeType magick_unused(length),

  unsigned char *magick_restrict magick_unused(message))

{

  magick_unreferenced(file);

  magick_unreferenced(length);

  magick_unreferenced(message);

  return(-1);

}

static inline MagickOffsetType dpc_receive_deadline(SOCKET_TYPE

  magick_unused(file),const MagickSizeType magick_unused(length),

  unsigned char *magick_restrict magick_unused(message),

  double magick_unused(deadline))

{

  magick_unreferenced(file);

  magick_unreferenced(length);

  magick_unreferenced(message);

  magick_unreferenced(deadline);

  return(-1);

}

#else

static void SetSocketReceiveTimeout(SOCKET_TYPE file,double seconds)

{

  /*

    Set a receive timeout.

  */

#if defined(MAGICKCORE_HAVE_WINSOCK2)

  {

    DWORD timeout = (DWORD) (seconds*1000.0);

    (void) setsockopt(file,SOL_SOCKET,SO_RCVTIMEO,

      (const char *) &timeout,sizeof(timeout));

  }

#else

  {

    struct timeval tv;

    tv.tv_sec=(int) seconds;

    tv.tv_usec=(int) ((seconds-(double) tv.tv_sec)*1000000.0);

    (void) setsockopt(file,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv));

  }

#endif

}

static inline MagickOffsetType dpc_receive(SOCKET_TYPE file,

  const MagickSizeType length,unsigned char *magick_restrict message)

{

  MagickOffsetType offset = 0;

  while (offset < (MagickOffsetType) length)

  {

    MagickSizeType chunk = MagickMin(length-offset,(MagickSizeType)

      MagickMaxBufferExtent);

    ssize_t count = recv(file,(char *) message+offset,(LENGTH_TYPE) chunk,0);

    if (count > 0)

      offset+=(MagickOffsetType) count;

    else

      if (count == 0)

        return(0);

      else

        {

#ifdef MAGICKCORE_HAVE_WINSOCK2

          int wsa_err = WSAGetLastError();

          if ((wsa_err == WSAEINTR) || (wsa_err == WSAEWOULDBLOCK))

            continue;

          if (wsa_err == WSAECONNRESET)

            return(-2);

#else

          if ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK))

            continue;

          if (errno == ECONNRESET)

            return(-2);

#endif

          return(-1);

        }

  }

  return(offset);

}

static inline MagickOffsetType dpc_receive_deadline(SOCKET_TYPE file,

  MagickSizeType length,unsigned char *message,double deadline)

{

  /*

    Enforce an absolute deadline for authentication and command reads.

  */

  MagickOffsetType offset = 0;

  while (offset < (MagickOffsetType) length)

  {

    double

      now = (double) time((time_t *) NULL),

      remaining = deadline-now;

    MagickSizeType

      chunk;

    ssize_t

      count;

    if (now >= deadline)

      return(-1);

    if (remaining < 0.001)

      remaining=0.001;

    SetSocketReceiveTimeout(file,remaining);

    chunk=MagickMin(length-offset,(MagickSizeType) MagickMaxBufferExtent);

    count=recv(file,(char *) message+offset,(LENGTH_TYPE) chunk,0);

    if (count > 0)

      offset+=(MagickOffsetType) count;

    else

      if (count == 0)

        return(0);

      else

        {

#ifdef MAGICKCORE_HAVE_WINSOCK2

          int wsa_err = WSAGetLastError();

          if ((wsa_err == WSAEINTR) || (wsa_err == WSAEWOULDBLOCK))

            continue;

          if (wsa_err == WSAECONNRESET)

            return(-2);

          return(-1);

#else

          if ((errno == EINTR) || (errno == EAGAIN) || (errno == EWOULDBLOCK))

            continue;

          if (errno == ECONNRESET)

            return(-2);

          return(-1);

#endif

        }

  }

  return(offset);

}

#endif

#if defined(MAGICKCORE_HAVE_WINSOCK2)

static void InitializeWinsock2(MagickBooleanType use_lock)

{

  if (use_lock != MagickFalse)

    {

      if (winsock_semaphore == (SemaphoreInfo *) NULL)

        ActivateSemaphoreInfo(&winsock_semaphore);

      LockSemaphoreInfo(winsock_semaphore);

    }

  if (wsaData == (WSADATA *) NULL)

    {

      wsaData=(WSADATA *) AcquireMagickMemory(sizeof(WSADATA));

      if (WSAStartup(MAKEWORD(2,2),wsaData) != 0)

        ThrowFatalException(CacheFatalError,"WSAStartup failed");

    }

  if (use_lock != MagickFalse)

    UnlockSemaphoreInfo(winsock_semaphore);

}

#endif

#if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

static int ConnectPixelCacheServer(const char *magick_unused(hostname),

  const int magick_unused(port),uint64_t *magick_unused(session_key),

  ExceptionInfo *exception)

{

  magick_unreferenced(hostname);

  magick_unreferenced(port);

  magick_unreferenced(session_key);

  (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,

    "DelegateLibrarySupportNotBuiltIn","distributed pixel cache");

  return(MagickFalse);

}

#else

static inline uint64_t ROTL(uint64_t x,int b)

{

  return((x << b) | (x >> (64-b)));

}

static inline uint64_t U8TO64_LE(const uint8_t *p)

{

  return(((uint64_t) p[0] << 0)  | ((uint64_t) p[1] << 8)  |

         ((uint64_t) p[2] << 16) | ((uint64_t) p[3] << 24) |

         ((uint64_t) p[4] << 32) | ((uint64_t) p[5] << 40) |

         ((uint64_t) p[6] << 48) | ((uint64_t) p[7] << 56));

}

static inline uint64_t SIPHash24(const uint8_t key[16],const uint8_t *message,

  const size_t length)

{

  const uint8_t

    *end = message+length-(length % 8);

  size_t

    i;

  uint64_t

    b = ((uint64_t) length) << 56,

    k0 = U8TO64_LE(key),

    k1 = U8TO64_LE(key+8),

    m,

    v0 = 0x736f6d6570736575ULL ^ k0,

    v1 = 0x646f72616e646f6dULL ^ k1,

    v2 = 0x6c7967656e657261ULL ^ k0,

    v3 = 0x7465646279746573ULL ^ k1;

  for ( ; message != end; message+=8)

  {

    m=U8TO64_LE(message);

    v3^=m;

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

    {

      v0+=v1; v1=ROTL(v1,13); v1^=v0; v0=ROTL(v0,32);

      v2+=v3; v3=ROTL(v3,16); v3^=v2;

      v0+=v3; v3=ROTL(v3,21); v3^=v0;

      v2+=v1; v1=ROTL(v1,17); v1^=v2; v2=ROTL(v2,32);

    }

    v0^=m;

  }

  switch (length & 0x07)

  {

    case 7: b|=((uint64_t) message[6]) << 48; magick_fallthrough;

    case 6: b|=((uint64_t) message[5]) << 40; magick_fallthrough;

    case 5: b|=((uint64_t) message[4]) << 32; magick_fallthrough;

    case 4: b|=((uint64_t) message[3]) << 24; magick_fallthrough;

    case 3: b|=((uint64_t) message[2]) << 16; magick_fallthrough;

    case 2: b|=((uint64_t) message[1]) << 8; magick_fallthrough;

    case 1: b|=((uint64_t) message[0]); magick_fallthrough;

    default: break;

  }

  v3^=b;

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

  {

    v0+=v1; v1=ROTL(v1,13); v1^=v0; v0=ROTL(v0,32);

    v2+=v3; v3=ROTL(v3,16); v3^=v2;

    v0+=v3; v3=ROTL(v3,21); v3^=v0;

    v2+=v1; v1=ROTL(v1,17); v1^=v2; v2=ROTL(v2,32);

  }

  v0^=b;

  v2^=0xff;

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

  {

    v0+=v1; v1=ROTL(v1,13); v1^=v0; v0=ROTL(v0,32);

    v2+=v3; v3=ROTL(v3,16); v3^=v2;

    v0+=v3; v3=ROTL(v3,21); v3^=v0;

    v2+=v1; v1=ROTL(v1,17); v1^=v2; v2=ROTL(v2,32);

  }

  return(v0^v1^v2^v3);

}

static inline void DeriveSIPKeyFromSecret(const char *shared_secret,

  uint8_t key[16])

{

  size_t

    i,

    length;

  uint64_t

    k0 = 0x0706050403020100ULL,

    k1 = 0x0f0e0d0c0b0a0908ULL;

  length=strlen(shared_secret);

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

  {

    uint8_t

      b = (uint8_t) shared_secret[i];

    k0^=b;

    k0*=0x100000001b3ULL;

    k1^=(uint64_t) b << ((i & 7)*8);

    k1=(k1 << 5) | (k1 >> (64-5));

  }

  (void) memcpy(key,&k0,8);

  (void) memcpy(key+8,&k1,8);

}

static inline uint64_t GenerateSessionKey(const char *shared_secret,

  const unsigned char *nonce,size_t length)

{

  uint8_t

    key[16];

  DeriveSIPKeyFromSecret(shared_secret,key);

  return(SIPHash24(key,nonce,length));

}

static int ConnectPixelCacheServer(const char *hostname,const int port,

  uint64_t *session_key,ExceptionInfo *exception)

{

#if defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

  char

    *message,

    service[MagickPathExtent],

    *shared_secret;

  int

    status;

  SOCKET_TYPE

    client_socket;

  ssize_t

    count;

  struct addrinfo

    hints,

    *result;

  unsigned char

    nonce[DPCSessionKeyLength];

  /*

    Connect to distributed pixel cache server and get session key.

  */

  *session_key=0;

#if defined(MAGICKCORE_HAVE_WINSOCK2)

  InitializeWinsock2(MagickTrue);

#endif

  (void) memset(&hints,0,sizeof(hints));

  hints.ai_family=AF_INET;

  hints.ai_socktype=SOCK_STREAM;

  hints.ai_flags=AI_PASSIVE;

  (void) FormatLocaleString(service,MagickPathExtent,"%d",port);

  status=getaddrinfo(hostname,service,&hints,&result);

  if (status != 0)

    {

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': %s",hostname,gai_strerror(status));

      return(-1);

    }

  client_socket=(SOCKET_TYPE) socket(result->ai_family,result->ai_socktype,

    result->ai_protocol);

  if (client_socket == -1)

    {

      freeaddrinfo(result);

      message=GetExceptionMessage(errno);

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': %s",hostname,message);

      message=DestroyString(message);

      return(-1);

    }

  status=connect(client_socket,result->ai_addr,(socklen_t) result->ai_addrlen);

  freeaddrinfo(result);

  if (status == -1)

    {

      CLOSE_SOCKET(client_socket);

      message=GetExceptionMessage(errno);

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': %s",hostname,message);

      message=DestroyString(message);

      return(-1);

    }

  /*

    Receive server nonce.

  */

  count=recv(client_socket,(char *) nonce,sizeof(nonce),0);

  if (count != (ssize_t) sizeof(nonce))

    {

      CLOSE_SOCKET(client_socket);

      message=GetExceptionMessage(errno);

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': %s",hostname,message);

      message=DestroyString(message);

      return(-1);

    }

  /*

    Compute keyed hash(shared_secret,nonce).

  */

  shared_secret=GetPolicyValue("cache:shared-secret");

  if (shared_secret == (const char *) NULL)

    {

      CLOSE_SOCKET(client_socket);

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': shared secret required",hostname);

      return(-1);

    }

  *session_key=GenerateSessionKey(shared_secret,nonce,sizeof(nonce));

  shared_secret=DestroyString(shared_secret);

  /*

    Send keyed hash back to client.

  */

  count=send(client_socket,(char *) session_key,sizeof(*session_key),

    MSG_NOSIGNAL);

  if (count != (ssize_t) sizeof(*session_key))

    {

      CLOSE_SOCKET(client_socket);

      (void) ThrowMagickException(exception,GetMagickModule(),CacheError,

        "DistributedPixelCache","'%s': authentication failed",hostname);

      return(-1);

    }

  return((int) client_socket);

#else

  (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,

    "DelegateLibrarySupportNotBuiltIn","distributed pixel cache");

  return(-1);

#endif

}

#endif

static char *GetHostname(int *port,ExceptionInfo *exception)

{

  char

    *host,

    *hosts,

    **hostlist;

  int

    argc;

  ssize_t

    i;

  static size_t

    id = 0;

  /*

    Parse host list (e.g. 192.168.100.1:6668,192.168.100.2:6668).

  */

  hosts=(char *) GetImageRegistry(StringRegistryType,"cache:hosts",exception);

  if (hosts == (char *) NULL)

    {

      *port=DPCPort;

      return(AcquireString(DPCHostname));

    }

  (void) SubstituteString(&hosts,","," ");

  hostlist=StringToArgv(hosts,&argc);

  hosts=DestroyString(hosts);

  if ((hostlist == (char **) NULL) || ((argc-1) == 0))

    {

      *port=DPCPort;

      return(AcquireString(DPCHostname));

    }

  {

    size_t host_count = (size_t) argc-1;

    size_t index = (id++ % host_count)+1;

    hosts=AcquireString(hostlist[index]);

  }

  for (i=0; i < (ssize_t) argc; i++)

    hostlist[i]=DestroyString(hostlist[i]);

  hostlist=(char **) RelinquishMagickMemory(hostlist);

  (void) SubstituteString(&hosts,":"," ");

  hostlist=StringToArgv(hosts,&argc);

  if (hostlist == (char **) NULL)

    {

      *port=DPCPort;

      return(AcquireString(DPCHostname));

    }

  host=AcquireString(hostlist[1]);

  if (hostlist[2] == (char *) NULL)

    *port=DPCPort;

  else

    *port=(int) StringToLong(hostlist[2]);

  for (i=0; i < (ssize_t) argc; i++)

    hostlist[i]=DestroyString(hostlist[i]);

  hostlist=(char **) RelinquishMagickMemory(hostlist);

  return(host);

}

MagickPrivate DistributeCacheInfo *AcquireDistributeCacheInfo(

  ExceptionInfo *exception)

{

  char

    *hostname;

  DistributeCacheInfo

    *server_info;

  uint64_t

    session_key;

  /*

    Connect to the distributed pixel cache server.

  */

  server_info=(DistributeCacheInfo *) AcquireCriticalMemory(

    sizeof(*server_info));

  (void) memset(server_info,0,sizeof(*server_info));

  server_info->signature=MagickCoreSignature;

  server_info->port=0;

  hostname=GetHostname(&server_info->port,exception);

  session_key=0;

  server_info->file=ConnectPixelCacheServer(hostname,server_info->port,

    &session_key,exception);

  if (server_info->file == -1)

    server_info=DestroyDistributeCacheInfo(server_info);

  else

    {

      server_info->session_key=session_key;

      (void) CopyMagickString(server_info->hostname,hostname,MagickPathExtent);

      server_info->debug=(GetLogEventMask() & CacheEvent) != 0 ? MagickTrue :

        MagickFalse;

    }

  hostname=DestroyString(hostname);

  return(server_info);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   D e s t r o y D i s t r i b u t e C a c h e I n f o                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyDistributeCacheInfo() deallocates memory associated with an

%  DistributeCacheInfo structure.

%

%  The format of the DestroyDistributeCacheInfo method is:

%

%      DistributeCacheInfo *DestroyDistributeCacheInfo(

%        DistributeCacheInfo *server_info)

%

%  A description of each parameter follows:

%

%    o server_info: the distributed cache info.

%

*/

MagickPrivate DistributeCacheInfo *DestroyDistributeCacheInfo(

  DistributeCacheInfo *server_info)

{

  assert(server_info != (DistributeCacheInfo *) NULL);

  assert(server_info->signature == MagickCoreSignature);

#if defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

  if (server_info->file >= 0)

    CLOSE_SOCKET(server_info->file);

#endif

  server_info->signature=(~MagickCoreSignature);

  server_info=(DistributeCacheInfo *) RelinquishMagickMemory(server_info);

  return(server_info);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   D i s t r i b u t e P i x e l C a c h e S e r v e r                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DistributePixelCacheServer() waits on the specified port for commands to

%  create, read, update, or destroy a pixel cache.

%

%  The format of the DistributePixelCacheServer() method is:

%

%      void DistributePixelCacheServer(const int port)

%

%  A description of each parameter follows:

%

%    o port: connect the distributed pixel cache at this port.

%

%    o exception: return any errors or warnings in this structure.

%

*/

#if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

static inline MagickOffsetType dpc_send(SOCKET_TYPE magick_unused(file),

  const MagickSizeType magick_unused(length),

  const void *magick_restrict magick_unused(message))

{

  magick_unreferenced(file);

  magick_unreferenced(length);

  magick_unreferenced(message);

  return(-1);

}

#else

static inline MagickOffsetType dpc_send(SOCKET_TYPE file,

  const MagickSizeType length,const void *magick_restrict message)

{

  MagickOffsetType

    i;

  ssize_t

    count;

  /*

    Ensure a complete message is sent.

  */

  count=0;

  for (i=0; i < (MagickOffsetType) length; i+=count)

  {

    count=(ssize_t) send(file,(const char *) message+i,(LENGTH_TYPE) MagickMin(

      length-(MagickSizeType) i,(MagickSizeType) MagickMaxBufferExtent),

      MSG_NOSIGNAL);

    if (count <= 0)

      {

        count=0;

        if (errno != EINTR)

          break;

      }

  }

  return(i);

}

#endif

#if !defined(MAGICKCORE_HAVE_DISTRIBUTE_CACHE)

MagickExport void DistributePixelCacheServer(const int magick_unused(port),

  ExceptionInfo *magick_unused(exception))

{

  magick_unreferenced(port);

  magick_unreferenced(exception);

  ThrowFatalException(MissingDelegateError,"DelegateLibrarySupportNotBuiltIn");

}

#else

static MagickBooleanType DestroyDistributeCache(SplayTreeInfo *registry,

  const uint64_t session_key)

{

  MagickAddressType

    key = (MagickAddressType) session_key;

  /*

    Destroy distributed pixel cache.

  */

  return(DeleteNodeFromSplayTree(registry,(const void *) key));

}

static MagickBooleanType OpenDistributeCache(SplayTreeInfo *registry,

  SOCKET_TYPE file,const uint64_t session_key,ExceptionInfo *exception)

{

  Image

    *image;

  MagickAddressType

    key = (MagickAddressType) session_key;

  MagickBooleanType

    status;

  MagickOffsetType

    count;

  MagickSizeType

    length;

  unsigned char

    message[MagickPathExtent],

    *p;

  /*

    Open distributed pixel cache.

  */

  image=AcquireImage((ImageInfo *) NULL,exception);

  if (image == (Image *) NULL)

    return(MagickFalse);

  length=sizeof(image->storage_class)+sizeof(image->colorspace)+

    sizeof(image->alpha_trait)+sizeof(image->channels)+sizeof(image->columns)+

    sizeof(image->rows)+sizeof(image->number_channels)+MaxPixelChannels*

    sizeof(*image->channel_map)+sizeof(image->metacontent_extent);

  count=dpc_receive(file,length,message);

  if (count != (MagickOffsetType) length)

    {

      image=DestroyImage(image);

      return(MagickFalse);

    }

  /*

    Deserialize the image attributes.

  */

  p=message;

  (void) memcpy(&image->storage_class,p,sizeof(image->storage_class));

  p+=(ptrdiff_t) sizeof(image->storage_class);

  (void) memcpy(&image->colorspace,p,sizeof(image->colorspace));

  p+=(ptrdiff_t) sizeof(image->colorspace);

  (void) memcpy(&image->alpha_trait,p,sizeof(image->alpha_trait));

  p+=(ptrdiff_t) sizeof(image->alpha_trait);

  (void) memcpy(&image->channels,p,sizeof(image->channels));

  p+=(ptrdiff_t) sizeof(image->channels);

  (void) memcpy(&image->columns,p,sizeof(image->columns));

  p+=(ptrdiff_t) sizeof(image->columns);

  (void) memcpy(&image->rows,p,sizeof(image->rows));

  p+=(ptrdiff_t) sizeof(image->rows);

  (void) memcpy(&image->number_channels,p,sizeof(image->number_channels));

  p+=(ptrdiff_t) sizeof(image->number_channels);

  (void) memcpy(image->channel_map,p,MaxPixelChannels*

    sizeof(*image->channel_map));

  p+=(ptrdiff_t) MaxPixelChannels*sizeof(*image->channel_map);

  (void) memcpy(&image->metacontent_extent,p,sizeof(image->metacontent_extent));

  p+=(ptrdiff_t) sizeof(image->metacontent_extent);

  if (SyncImagePixelCache(image,exception) == MagickFalse)

    {

      image=DestroyImage(image);

      return(MagickFalse);

    }

  status=AddValueToSplayTree(registry,(const void *) key,image);

  if (status == MagickFalse)

    {

      image=DestroyImage(image);

      return(MagickFalse);

    }

  return(status);

}

static inline MagickBooleanType ValidateDistributedPixelCache(

  const RectangleInfo *region,const size_t per_pixel,

  const MagickSizeType length)

{

  size_t

    extent = 0,

    pixels = 0;

  if (HeapOverflowSanityCheckGetSize(region->width,region->height,&pixels) != MagickFalse)

    return(MagickFalse);

  if (HeapOverflowSanityCheckGetSize(pixels,per_pixel,&extent) != MagickFalse)

    return(MagickFalse);

  if (length > (MagickSizeType) extent)

    return(MagickFalse);

  return(MagickTrue);

}

static MagickBooleanType ReadDistributeCacheMetacontent(SplayTreeInfo *registry,

  SOCKET_TYPE file,const uint64_t session_key,ExceptionInfo *exception)

{

  const Quantum

    *p;

  const unsigned char

    *metacontent;

  Image

    *image;

  MagickAddressType

    key = (MagickAddressType) session_key;

  MagickOffsetType

    count;

  MagickSizeType

    length;

  RectangleInfo

    region;

  size_t

    per_pixel;

  unsigned char

    message[MagickPathExtent],

    *q;

  /*

    Read distributed pixel cache metacontent.

  */

  image=(Image *) GetValueFromSplayTree(registry,(const void *) key);

  if (image == (Image *) NULL)

    return(MagickFalse);

  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+

    sizeof(region.y)+sizeof(length);

  count=dpc_receive(file,length,message);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  q=message;

  (void) memcpy(&region.width,q,sizeof(region.width));

  q+=(ptrdiff_t) sizeof(region.width);

  (void) memcpy(&region.height,q,sizeof(region.height));

  q+=(ptrdiff_t) sizeof(region.height);

  (void) memcpy(&region.x,q,sizeof(region.x));

  q+=(ptrdiff_t) sizeof(region.x);

  (void) memcpy(&region.y,q,sizeof(region.y));

  q+=(ptrdiff_t) sizeof(region.y);

  (void) memcpy(&length,q,sizeof(length));

  q+=(ptrdiff_t) sizeof(length);

  per_pixel=image->number_meta_channels*sizeof(Quantum);

  if (ValidateDistributedPixelCache(&region,per_pixel,length) == MagickFalse)

    return(MagickFalse);

  p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,

    exception);

  if (p == (const Quantum *) NULL)

    return(MagickFalse);

  metacontent=(const unsigned char *) GetVirtualMetacontent(image);

  count=dpc_send(file,length,metacontent);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  return(MagickTrue);

}

static MagickBooleanType ReadDistributeCachePixels(SplayTreeInfo *registry,

  SOCKET_TYPE file,const uint64_t session_key,ExceptionInfo *exception)

{

  const Quantum

    *p;

  Image

    *image;

  MagickAddressType

    key = (MagickAddressType) session_key;

  MagickOffsetType

    count;

  MagickSizeType

    length;

  RectangleInfo

    region;

  size_t

    per_pixel;

  unsigned char

    message[MagickPathExtent],

    *q;

  /*

    Read distributed pixel cache pixels.

  */

  image=(Image *) GetValueFromSplayTree(registry,(const void *) key);

  if (image == (Image *) NULL)

    return(MagickFalse);

  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+

    sizeof(region.y)+sizeof(length);

  count=dpc_receive(file,length,message);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  q=message;

  (void) memcpy(&region.width,q,sizeof(region.width));

  q+=(ptrdiff_t) sizeof(region.width);

  (void) memcpy(&region.height,q,sizeof(region.height));

  q+=(ptrdiff_t) sizeof(region.height);

  (void) memcpy(&region.x,q,sizeof(region.x));

  q+=(ptrdiff_t) sizeof(region.x);

  (void) memcpy(&region.y,q,sizeof(region.y));

  q+=(ptrdiff_t) sizeof(region.y);

  (void) memcpy(&length,q,sizeof(length));

  per_pixel=image->number_channels*sizeof(Quantum);

  if (ValidateDistributedPixelCache(&region,per_pixel,length) == MagickFalse)

    return(MagickFalse);

  q+=(ptrdiff_t) sizeof(length);

  p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,

    exception);

  if (p == (const Quantum *) NULL)

    return(MagickFalse);

  count=dpc_send(file,length,p);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  return(MagickTrue);

}

static void *RelinquishImageRegistry(void *image)

{

  return((void *) DestroyImageList((Image *) image));

}

static MagickBooleanType WriteDistributeCacheMetacontent(

  SplayTreeInfo *registry,SOCKET_TYPE file,const uint64_t session_key,

  ExceptionInfo *exception)

{

  Image

    *image;

  MagickAddressType

    key = (MagickAddressType) session_key;

  MagickOffsetType

    count;

  MagickSizeType

    length;

  Quantum

    *q;

  RectangleInfo

    region;

  size_t

    per_pixel;

  unsigned char

    message[MagickPathExtent],

    *metacontent,

    *p;

  /*

    Write distributed pixel cache metacontent.

  */

  image=(Image *) GetValueFromSplayTree(registry,(const void *) key);

  if (image == (Image *) NULL)

    return(MagickFalse);

  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+

    sizeof(region.y)+sizeof(length);

  count=dpc_receive(file,length,message);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  p=message;

  (void) memcpy(&region.width,p,sizeof(region.width));

  p+=(ptrdiff_t) sizeof(region.width);

  (void) memcpy(&region.height,p,sizeof(region.height));

  p+=(ptrdiff_t) sizeof(region.height);

  (void) memcpy(&region.x,p,sizeof(region.x));

  p+=(ptrdiff_t) sizeof(region.x);

  (void) memcpy(&region.y,p,sizeof(region.y));

  p+=(ptrdiff_t) sizeof(region.y);

  (void) memcpy(&length,p,sizeof(length));

  per_pixel=image->number_meta_channels*sizeof(Quantum);

  if (ValidateDistributedPixelCache(&region,per_pixel,length) == MagickFalse)

    return(MagickFalse);

  p+=(ptrdiff_t) sizeof(length);

  q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,

    exception);

  if (q == (Quantum *) NULL)

    return(MagickFalse);

  metacontent=(unsigned char *) GetAuthenticMetacontent(image);

  count=dpc_receive(file,length,metacontent);

  if (count != (MagickOffsetType) length)

    return(MagickFalse);

  return(SyncAuthenticPixels(image,exception));

}

static MagickBooleanType WriteDistributeCachePixels(SplayTreeInfo *registry,

  SOCKET_TYPE file,const uint64_t session_key,ExceptionInfo *exception)

{

  Image

    *image;

  MagickAddressType

    key = (MagickAddressType) session_key;

  MagickOffsetType

    count;

  MagickSizeType

    length;

  Quantum

    *q;

  RectangleInfo

    region;

  size_t

    per_pixel;

  unsigned char

    message[MagickPathExtent],

    *p;

  /*

    Write distributed pixel cache pixels.

  */