← Back to branch summary

~ubuntu-branches/ubuntu/warty/openafs/warty

« back to all changes in this revision

Viewing changes to src/tests/xf_rxcall.c

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hartman
  • Date: 2004-01-10 16:37:33 UTC
  • Revision ID: james.westby@ubuntu.com-20040110163733-jvr0n1uahshlb1uu
Tags: upstream-1.2.11
Import upstream version 1.2.11

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/xf_rxcall.c
 
1
/*
 
2
 * CMUCS AFStools
 
3
 * dumpscan - routines for scanning and manipulating AFS volume dumps
 
4
 *
 
5
 * Copyright (c) 1998 Carnegie Mellon University
 
6
 * All Rights Reserved.
 
7
 * 
 
8
 * Permission to use, copy, modify and distribute this software and its
 
9
 * documentation is hereby granted, provided that both the copyright
 
10
 * notice and this permission notice appear in all copies of the
 
11
 * software, derivative works or modified versions, and any portions
 
12
 * thereof, and that both notices appear in supporting documentation.
 
13
 *
 
14
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 
15
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 
16
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 
17
 *
 
18
 * Carnegie Mellon requests users of this software to return to
 
19
 *
 
20
 *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
 
21
 *  School of Computer Science
 
22
 *  Carnegie Mellon University
 
23
 *  Pittsburgh PA 15213-3890
 
24
 *
 
25
 * any improvements or extensions that they make and grant Carnegie Mellon
 
26
 * the rights to redistribute these changes.
 
27
 */
 
28
 
 
29
/* xf_rxcall.c - XFILE routines for Rx bulk data transfers */
 
30
 
 
31
#include <sys/types.h>
 
32
#include <netinet/in.h>
 
33
#include <errno.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
#include <fcntl.h>
 
37
#include <netdb.h>
 
38
 
 
39
#include "xfiles.h"
 
40
#include "xf_errs.h"
 
41
 
 
42
#include <rx/xdr.h>
 
43
#include <rx/rx.h>
 
44
#include <rx/rx_null.h>
 
45
#include <rx/rxkad.h>
 
46
#include <afs/auth.h>
 
47
#include <afs/cellconfig.h>
 
48
#include <afs/vlserver.h>
 
49
#include <afs/volser.h>
 
50
 
 
51
#ifndef AFSCONF_CLIENTNAME
 
52
#include <afs/dirpath.h>
 
53
#define AFSCONF_CLIENTNAME AFSDIR_CLIENT_ETC_DIRPATH
 
54
#endif
 
55
 
 
56
#define O_MODE_MASK (O_RDONLY | O_WRONLY | O_RDWR)
 
57
 
 
58
struct rxinfo {
 
59
  struct rx_connection *conn;  /* connection */
 
60
  struct rx_call *call;        /* call */
 
61
  afs_int32 tid;                   /* volser transaction ID */
 
62
  afs_uint32 code;                /* result code */
 
63
};
 
64
 
 
65
static afs_uint32 xf_rxcall_do_read(XFILE *X, void *buf, afs_uint32 count)
 
66
{
 
67
  struct rxinfo *i = X->refcon;
 
68
  afs_uint32 xcount;
 
69
 
 
70
  xcount = rx_Read(i->call, buf, count);
 
71
  if (xcount == count) return 0;
 
72
  i->code = rx_EndCall(i->call, 0);
 
73
  i->call = 0;
 
74
  return i->code ? i->code : ERROR_XFILE_RDONLY;
 
75
}
 
76
 
 
77
 
 
78
static afs_uint32 xf_rxcall_do_write(XFILE *X, void *buf, afs_uint32 count)
 
79
{
 
80
  struct rxinfo *i = X->refcon;
 
81
  afs_uint32 xcount;
 
82
 
 
83
  xcount = rx_Write(i->call, buf, count);
 
84
  if (xcount == count) return 0;
 
85
  i->code = rx_EndCall(i->call, 0);
 
86
  i->call = 0;
 
87
  return i->code;
 
88
}
 
89
 
 
90
 
 
91
static afs_uint32 xf_rxcall_do_close(XFILE *X)
 
92
{
 
93
  struct rxinfo *i = X->refcon;
 
94
  afs_uint32 code;
 
95
 
 
96
  if (i->call) {
 
97
    code = rx_EndCall(i->call, i->code);
 
98
    i->call = 0;
 
99
  } else {
 
100
    code = i->code;
 
101
  }
 
102
  free(i);
 
103
  return code;
 
104
}
 
105
 
 
106
 
 
107
static afs_uint32 xf_voldump_do_close(XFILE *X)
 
108
{
 
109
  struct rxinfo *i = X->refcon;
 
110
  struct rx_connection *conn = i->conn;
 
111
  afs_uint32 code, rcode, xcode;
 
112
  afs_int32 tid = i->tid;
 
113
 
 
114
  code = xf_rxcall_do_close(X);
 
115
  xcode = AFSVolEndTrans(conn, tid, &rcode);
 
116
  if (!code) code = xcode ? xcode : rcode;
 
117
  return code;
 
118
}
 
119
 
 
120
 
 
121
afs_uint32 xfopen_rxcall(XFILE *X, int flag, struct rx_call *call)
 
122
{
 
123
  struct rxinfo *i;
 
124
 
 
125
  flag &= O_MODE_MASK;
 
126
  if (flag == O_WRONLY) return ERROR_XFILE_WRONLY;
 
127
  memset(X, 0, sizeof(*X));
 
128
  if (!(i = (struct rxinfo *)malloc(sizeof(struct rxinfo)))) return ENOMEM;
 
129
  i->call = call;
 
130
  i->code = 0;
 
131
  X->do_read  = xf_rxcall_do_read;
 
132
  X->do_write = xf_rxcall_do_write;
 
133
  X->do_close = xf_rxcall_do_close;
 
134
  X->is_writable = (flag == O_RDWR);
 
135
  X->refcon = i;
 
136
  return 0;
 
137
}
 
138
 
 
139
 
 
140
afs_uint32 xfopen_voldump(XFILE *X, struct rx_connection *conn,
 
141
                       afs_int32 part, afs_int32 volid, afs_int32 date)
 
142
{
 
143
  struct rx_call *call;
 
144
  struct rxinfo *i;
 
145
  afs_uint32 code, rcode;
 
146
  afs_int32 tid;
 
147
 
 
148
  if (code = AFSVolTransCreate(conn, volid, part, ITBusy, &tid)) return code;
 
149
  call = rx_NewCall(conn);
 
150
  if ((code = StartAFSVolDump(call, tid, date))
 
151
  ||  (code = xfopen_rxcall(X, O_RDONLY, call))) {
 
152
    rx_EndCall(call, 0);
 
153
    AFSVolEndTrans(conn, tid, &rcode);
 
154
    return code;
 
155
  }
 
156
 
 
157
  i = X->refcon;
 
158
  i->conn = conn;
 
159
  i->tid = tid;
 
160
  X->do_close = xf_voldump_do_close;
 
161
  return 0;
 
162
}
 
163
 
 
164
 
 
165
afs_uint32 xfon_voldump(XFILE *X, int flag, char *name)
 
166
{
 
167
  struct hostent *he;
 
168
  struct rx_securityClass *class;
 
169
  struct rx_connection *conn;
 
170
  struct ktc_principal sname;
 
171
  struct ktc_token token;
 
172
  struct afsconf_dir *confdir;
 
173
  afs_uint32 code, server_addr;
 
174
  afs_int32 volid, partid, date;
 
175
  int isnum, index;
 
176
  char *x, *y;
 
177
 
 
178
  /* Parse out the optional date and server location */
 
179
  if (code = rx_Init(0)) return code;
 
180
  if (!(name = strdup(name))) return ENOMEM;
 
181
  if (x = strrchr(name, ',')) {
 
182
    *x++ = 0;
 
183
    date = atoi(x);
 
184
  } else {
 
185
    date = 0;
 
186
  }
 
187
  if (x = strrchr(name, '@')) {
 
188
    int a, b, c, d;
 
189
 
 
190
    *x++ = 0;
 
191
    if (!(y = strchr(x, '/'))) {
 
192
      free(name);
 
193
      return VL_BADPARTITION;
 
194
    }
 
195
    *y++ = 0;
 
196
    if (sscanf(x, "%d.%d.%d.%d", &a, &b, &c, &d) == 4
 
197
    &&  a >= 0 && a <= 255 && b >= 0 && b <= 255
 
198
    &&  c >= 0 && c <= 255 && d >= 0 && d <= 255) {
 
199
      server_addr = (a << 24) | (b << 16) | (c << 8) | d;
 
200
      server_addr = htonl(server_addr);
 
201
    } else {
 
202
      he = gethostbyname(x);
 
203
      if (!he) {
 
204
        free(name);
 
205
        return VL_BADSERVER;
 
206
      }
 
207
      memcpy(&server_addr, he->h_addr, sizeof(server_addr));
 
208
    }
 
209
    partid = volutil_GetPartitionID(y);
 
210
    if (partid < 0) {
 
211
      free(name);
 
212
      return VL_BADPARTITION;
 
213
    }
 
214
  }
 
215
 
 
216
  /* Get tokens and set up a security object */
 
217
  confdir = afsconf_Open(AFSCONF_CLIENTNAME);
 
218
  if (!confdir) {
 
219
    free(name);
 
220
    return AFSCONF_NODB;
 
221
  }
 
222
  if (code = afsconf_GetLocalCell(confdir, sname.cell, MAXKTCNAMELEN)) {
 
223
    free(name);
 
224
    return code;
 
225
  }
 
226
  afsconf_Close(confdir);
 
227
  strcpy(sname.name, "afs");
 
228
  sname.instance[0] = 0;
 
229
  code = ktc_GetToken(&sname, &token, sizeof(token), 0);
 
230
  if (code) {
 
231
    class = rxnull_NewClientSecurityObject();
 
232
    index = 0;
 
233
  } else {
 
234
    class = rxkad_NewClientSecurityObject(rxkad_clear, &token.sessionKey,
 
235
            token.kvno, token.ticketLen, token.ticket);
 
236
    index = 2;
 
237
  }
 
238
 
 
239
  /* Figure out the volume ID, looking it up in the VLDB if neccessary.
 
240
   * Also look up the server and partition, if they were not specified.
 
241
   */
 
242
  for (isnum = 1, y = name; *y; y++)
 
243
    if (*y < '0' || *y > '9') isnum = 0;
 
244
  if (isnum) {
 
245
    volid = atoi(name);
 
246
    if (!x) {
 
247
      fprintf(stderr, "XXX: need to lookup volume by ID!\n");
 
248
      exit(-1);
 
249
    }
 
250
  } else {
 
251
    fprintf(stderr, "XXX: need to lookup volume by name!\n");
 
252
    exit(-1);
 
253
  }
 
254
  free(name);
 
255
 
 
256
  /* Establish a connection and start the call */
 
257
  conn = rx_NewConnection(server_addr, htons(AFSCONF_VOLUMEPORT),
 
258
                          VOLSERVICE_ID, class, index);
 
259
  return xfopen_voldump(X, conn, partid, volid, date);
 
260
}