src/register.c

   1 /******************************************************************************
   2
   3
   4 Copyright 1993, 1998  The Open Group
   5
   6 Permission to use, copy, modify, distribute, and sell this software and its
   7 documentation for any purpose is hereby granted without fee, provided that
   8 the above copyright notice appear in all copies and that both that
   9 copyright notice and this permission notice appear in supporting
  10 documentation.
  11
  12 The above copyright notice and this permission notice shall be included in
  13 all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  18 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 Except as contained in this notice, the name of The Open Group shall not be
  23 used in advertising or otherwise to promote the sale, use or other dealings
  24 in this Software without prior written authorization from The Open Group.
  25
  26 Author: Ralph Mor, X Consortium
  27 ******************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32 #include <X11/ICE/ICElib.h>
  33 #include "ICElibint.h"
  34
  35 int
  36 IceRegisterForProtocolSetup (
  37         char                    *protocolName,
  38         char                    *vendor,
  39         char                    *release,
  40         int                     versionCount,
  41         IcePoVersionRec         *versionRecs,
  42         int                     authCount,
  43         const char              **authNames,
  44         IcePoAuthProc           *authProcs,
  45         IceIOErrorProc          IOErrorProc
  46 )
  47 {
  48     _IcePoProtocol      *p;
  49     int                 opcodeRet, i;
  50
  51     for (i = 1; i <= _IceLastMajorOpcode; i++)
  52         if (strcmp (protocolName, _IceProtocols[i - 1].protocol_name) == 0)
  53         {
  54             if (_IceProtocols[i - 1].orig_client != NULL)
  55             {
  56                 /*
  57                  * We've already registered this protocol.
  58                  */
  59
  60                 return (i);
  61             }
  62             else
  63             {
  64                 break;
  65             }
  66         }
  67
  68     if (i <= _IceLastMajorOpcode)
  69     {
  70         p = _IceProtocols[i - 1].orig_client =
  71             (_IcePoProtocol *) malloc (sizeof (_IcePoProtocol));
  72         opcodeRet = i;
  73     }
  74     else if (_IceLastMajorOpcode == 255 ||
  75         versionCount < 1 ||
  76         strlen (protocolName) == 0)
  77     {
  78         return (-1);
  79     }
  80     else
  81     {
  82         char *name;
  83
  84         _IceProtocols[_IceLastMajorOpcode].protocol_name = name =
  85             strdup(protocolName);
  86
  87         p = _IceProtocols[_IceLastMajorOpcode].orig_client =
  88             (_IcePoProtocol *) malloc (sizeof (_IcePoProtocol));
  89
  90         _IceProtocols[_IceLastMajorOpcode].accept_client = NULL;
  91
  92         opcodeRet = ++_IceLastMajorOpcode;
  93     }
  94
  95     p->vendor = strdup(vendor);
  96     p->release = strdup(release);
  97
  98     p->version_count = versionCount;
  99
 100     p->version_recs = (IcePoVersionRec *) malloc (
 101         versionCount * sizeof (IcePoVersionRec));
 102     memcpy (p->version_recs, versionRecs,
 103         versionCount * sizeof (IcePoVersionRec));
 104
 105     if ((p->auth_count = authCount) > 0)
 106     {
 107         p->auth_names = (char **) malloc (
 108             authCount * sizeof (char *));
 109
 110         p->auth_procs = (IcePoAuthProc *) malloc (
 111             authCount * sizeof (IcePoAuthProc));
 112
 113         for (i = 0; i < authCount; i++)
 114         {
 115             p->auth_names[i] = strdup(authNames[i]);
 116             p->auth_procs[i] = authProcs[i];
 117         }
 118     }
 119     else
 120     {
 121         p->auth_names = NULL;
 122         p->auth_procs = NULL;
 123     }
 124
 125     p->io_error_proc = IOErrorProc;
 126
 127     return (opcodeRet);
 128 }
 129
 130
 131 \f
 132 int
 133 IceRegisterForProtocolReply (
 134         char                            *protocolName,
 135         char                            *vendor,
 136         char                            *release,
 137         int                             versionCount,
 138         IcePaVersionRec                 *versionRecs,
 139         int                             authCount,
 140         const char                      **authNames,
 141         IcePaAuthProc                   *authProcs,
 142         IceHostBasedAuthProc            hostBasedAuthProc,
 143         IceProtocolSetupProc            protocolSetupProc,
 144         IceProtocolActivateProc         protocolActivateProc,
 145         IceIOErrorProc                  IOErrorProc
 146 )
 147 {
 148     _IcePaProtocol      *p;
 149     int                 opcodeRet, i;
 150
 151     for (i = 1; i <= _IceLastMajorOpcode; i++)
 152         if (strcmp (protocolName, _IceProtocols[i - 1].protocol_name) == 0)
 153         {
 154             if (_IceProtocols[i - 1].accept_client != NULL)
 155             {
 156                 /*
 157                  * We've already registered this protocol.
 158                  */
 159
 160                 return (i);
 161             }
 162             else
 163             {
 164                 break;
 165             }
 166         }
 167
 168
 169     if (i <= _IceLastMajorOpcode)
 170     {
 171         p = _IceProtocols[i - 1].accept_client =
 172             (_IcePaProtocol *) malloc (sizeof (_IcePaProtocol));
 173         opcodeRet = i;
 174     }
 175     else if (_IceLastMajorOpcode == 255 ||
 176         versionCount < 1 ||
 177         strlen (protocolName) == 0)
 178     {
 179         return (-1);
 180     }
 181     else
 182     {
 183         char *name;
 184
 185         _IceProtocols[_IceLastMajorOpcode].protocol_name = name =
 186             strdup(protocolName);
 187
 188         _IceProtocols[_IceLastMajorOpcode].orig_client = NULL;
 189
 190         p = _IceProtocols[_IceLastMajorOpcode].accept_client =
 191             (_IcePaProtocol *) malloc (sizeof (_IcePaProtocol));
 192
 193         opcodeRet = ++_IceLastMajorOpcode;
 194     }
 195
 196     p->vendor = strdup(vendor);
 197     p->release = strdup(release);
 198
 199     p->version_count = versionCount;
 200
 201     p->version_recs = (IcePaVersionRec *) malloc (
 202         versionCount * sizeof (IcePaVersionRec));
 203     memcpy (p->version_recs, versionRecs,
 204         versionCount * sizeof (IcePaVersionRec));
 205
 206     p->protocol_setup_proc = protocolSetupProc;
 207     p->protocol_activate_proc = protocolActivateProc;
 208
 209     if ((p->auth_count = authCount) > 0)
 210     {
 211         p->auth_names = (char **) malloc (
 212             authCount * sizeof (char *));
 213
 214         p->auth_procs = (IcePaAuthProc *) malloc (
 215             authCount * sizeof (IcePaAuthProc));
 216
 217         for (i = 0; i < authCount; i++)
 218         {
 219             p->auth_names[i] = strdup(authNames[i]);
 220             p->auth_procs[i] = authProcs[i];
 221         }
 222     }
 223     else
 224     {
 225         p->auth_names = NULL;
 226         p->auth_procs = NULL;
 227     }
 228
 229     p->host_based_auth_proc = hostBasedAuthProc;
 230
 231     p->io_error_proc = IOErrorProc;
 232
 233     return (opcodeRet);
 234 }
 235