tests/rpctestlib/rpc_test_cb_procs.c

   1 /*
   2  * Copyright (c) 2010, Linux Box Corporation.
   3  * All Rights Reserved.
   4  *
   5  * Portions Copyright (c) 2007, Hartmut Reuter,
   6  * RZG, Max-Planck-Institut f. Plasmaphysik.
   7  * All Rights Reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are met:
  11  *
  12  *   1. Redistributions of source code must retain the above copyright
  13  *      notice, this list of conditions and the following disclaimer.
  14  *   2. Redistributions in binary form must reproduce the above copyright
  15  *      notice, this list of conditions and the following disclaimer in
  16  *      the documentation and/or other materials provided with the
  17  *      distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  21  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  27  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <afsconfig.h>
  32 #include <afs/param.h>
  33
  34 #include <roken.h>
  35
  36 #include <afs/stds.h>
  37
  38 #include "rpc_test_procs.h"
  39
  40 #include <stdio.h>
  41 #include <sys/types.h>
  42 #include <string.h>
  43 #include <sys/stat.h>
  44 #include <errno.h>
  45 #include <signal.h>
  46 #include <afs/vice.h>
  47 #include <afs/cmd.h>
  48 #include <afs/auth.h>
  49 #include <afs/cellconfig.h>
  50
  51 #include <afs/com_err.h>
  52 #ifdef HAVE_DIRENT_H
  53 #include <dirent.h>
  54 #endif
  55 #ifdef HAVE_DIRECT_H
  56 #include <direct.h>
  57 #endif
  58 #ifdef AFS_DARWIN_ENV
  59 #include <sys/malloc.h>
  60 #endif
  61 #include <afs/errors.h>
  62 #include <afs/sys_prototypes.h>
  63 #include <rx/rx_prototypes.h>
  64 #ifdef AFS_PTHREAD_ENV
  65 #include <assert.h>
  66 #endif
  67
  68 extern const char *prog;
  69 extern pthread_key_t ctx_key;
  70
  71 #if defined(AFS_EXTENDED_CALLBACK)
  72 #define RPC_TEST_EXTENDED_CALLBACK  1
  73
  74 afs_int32 SRXAFSCB_ExtendedCallBack(
  75     /*IN */ struct rx_call *a_call,
  76     /*IN */ HostIdentifier * Server,
  77     /*IN */ AFSXCBInvocationSeq * Invocations_Array,
  78     /*OUT*/ AFSExtendedCallBackRSeq * CallBack_Result_Array)
  79 {
  80     rpc_test_request_ctx *ctx;
  81
  82     ctx = CTX_FOR_RXCALL(a_call);
  83
  84     printf("%s: SRXAFSCB_ExtendedCallBack: enter (%s)\n", prog,
  85         ctx->cb_svc_name);
  86
  87     return (0);
  88 };
  89 #endif /* AFS_EXTENDED_CALLBACK */
  90
  91 #if defined(AFS_BYTE_RANGE_FLOCKS)
  92 afs_int32 SRXAFSCB_AsyncIssueByteRangeLock(
  93         /*IN */ struct rx_call *a_call,
  94         /*IN */ HostIdentifier * Server,
  95         /*IN */ AFSByteRangeLockSeq Locks_Array)
  96 {
  97     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
  98
  99     printf("%s: SRXAFSCB_AsyncIssueByteRangeLock: enter (%s)\n", prog,
 100         ctx->cb_svc_name);
 101
 102     return (0);
 103 }
 104 #endif /* AFS_BYTE_RANGE_FLOCKS */
 105
 106 afs_int32
 107 SRXAFSCB_CallBack(struct rx_call *a_call, AFSCBFids *Fids_Array,
 108                   AFSCBs *CallBack_Array)
 109 {
 110     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
 111
 112     printf("%s: SRXAFSCB_CallBack: enter (%s)\n", prog,
 113         ctx->cb_svc_name);
 114
 115     return (0);
 116 }
 117
 118
 119 afs_int32
 120 SRXAFSCB_InitCallBackState(struct rx_call *a_call)
 121 {
 122     return (0);
 123 }
 124
 125
 126 afs_int32
 127 SRXAFSCB_Probe(struct rx_call *a_call)
 128 {
 129     return (0);
 130 }
 131
 132
 133 afs_int32
 134 SRXAFSCB_GetCE(struct rx_call *a_call,
 135                afs_int32 index,
 136                AFSDBCacheEntry * ce)
 137 {
 138     return(0);
 139 }
 140
 141
 142 afs_int32
 143 SRXAFSCB_GetLock(struct rx_call *a_call,
 144                  afs_int32 index,
 145                  AFSDBLock * lock)
 146 {
 147     return(0);
 148 }
 149
 150
 151 afs_int32
 152 SRXAFSCB_XStatsVersion(struct rx_call *a_call,
 153                        afs_int32 * versionNumberP)
 154 {
 155     return(0);
 156 }
 157
 158
 159 afs_int32
 160 SRXAFSCB_GetXStats(struct rx_call *a_call,
 161                    afs_int32 clientVersionNumber,
 162                    afs_int32 collectionNumber,
 163                    afs_int32 * srvVersionNumberP,
 164                    afs_int32 * timeP,
 165                    AFSCB_CollData * dataP)
 166 {
 167     return(0);
 168 }
 169
 170 afs_int32
 171 SRXAFSCB_ProbeUuid(struct rx_call *a_call, afsUUID *a_uuid)
 172 {
 173     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
 174     if ( !afs_uuid_equal(&ctx->cb_listen_addr.uuid, a_uuid) )
 175         return (1);
 176     else
 177         return (0);
 178 }
 179
 180
 181 afs_int32
 182 SRXAFSCB_WhoAreYou(struct rx_call *a_call, struct interfaceAddr *addr)
 183 {
 184     return SRXAFSCB_TellMeAboutYourself(a_call, addr, NULL);
 185 }
 186
 187
 188 afs_int32
 189 SRXAFSCB_InitCallBackState2(struct rx_call *a_call, struct interfaceAddr *
 190                             addr)
 191 {
 192     return RXGEN_OPCODE;
 193 }
 194
 195
 196 afs_int32
 197 SRXAFSCB_InitCallBackState3(struct rx_call *a_call, afsUUID *a_uuid)
 198 {
 199     return (0);
 200 }
 201
 202
 203 afs_int32
 204 SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
 205                         afs_uint32 *serverVersion, afs_uint32 *configCount,
 206                         cacheConfig *config)
 207 {
 208     return RXGEN_OPCODE;
 209 }
 210
 211 afs_int32
 212 SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
 213 {
 214     return RXGEN_OPCODE;
 215 }
 216
 217
 218 afs_int32
 219 SRXAFSCB_GetCellServDB(struct rx_call *a_call, afs_int32 a_index,
 220                        char **a_name, serverList *a_hosts)
 221 {
 222     return RXGEN_OPCODE;
 223 }
 224
 225
 226 afs_int32
 227 SRXAFSCB_GetServerPrefs(struct rx_call *a_call, afs_int32 a_index,
 228                         afs_int32 *a_srvr_addr, afs_int32 *a_srvr_rank)
 229 {
 230     return RXGEN_OPCODE;
 231 }
 232
 233
 234 afs_int32
 235 SRXAFSCB_TellMeAboutYourself(struct rx_call *a_call, struct interfaceAddr *
 236                              addr, Capabilities *capabilities)
 237 {
 238     rpc_test_request_ctx *ctx = CTX_FOR_RXCALL(a_call);
 239
 240     printf("%s: SRXAFSCB_TellMeAboutYourself: enter (%s)\n", prog,
 241         ctx->cb_svc_name);
 242
 243     addr->numberOfInterfaces = ctx->cb_listen_addr.numberOfInterfaces;
 244     addr->uuid = ctx->cb_listen_addr.uuid;
 245
 246     if (capabilities) {
 247         afs_uint32 *dataBuffP;
 248         afs_int32 dataBytes;
 249
 250         dataBytes = 1 * sizeof(afs_uint32);
 251         dataBuffP = (afs_uint32 *) xdr_alloc(dataBytes);
 252         dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
 253 #if defined(AFS_EXTENDED_CALLBACK)
 254         if (ctx->flags & RPC_TEST_REQ_CTX_FLAG_XCB)
 255             dataBuffP[0] |= CLIENT_CAPABILITY_EXT_CALLBACK;
 256 #endif /* AFS_EXTENDED_CALLBACK */
 257         capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
 258         capabilities->Capabilities_val = dataBuffP;
 259     }
 260
 261     return (0);
 262
 263 }        /* SRXAFSCB_TellMeAboutYourself */
 264
 265
 266 afs_int32
 267 SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_cellnum,
 268                       char **a_name, serverList *a_hosts)
 269 {
 270     return RXGEN_OPCODE;
 271 }
 272
 273
 274 afs_int32
 275 SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
 276                  struct AFSDBCacheEntry64 *a_result)
 277 {
 278     return RXGEN_OPCODE;
 279 }