AFS
view release on metacpan or search on metacpan
/***********************************************************************
*
* AFS.xs - AFS extensions for Perl
*
* RCS-Id: @(#)$RCS-Id: src/AFS.xs 73757dc Thu Oct 23 12:46:20 2014 +0200 Norbert E Gruener$
*
* Copyright (c) 2003, International Business Machines Corporation and others.
*
* This software has been released under the terms of the IBM Public
* License. For details, see the IBM-LICENSE file in the LICENCES
* directory or online at http://www.openafs.org/dl/license10.html
*
* Contributors
* 2004-2014: Norbert E. Gruener <nog@MPA-Garching.MPG.de>
* 2003: Alf Wachsmann <alfw@slac.stanford.edu>
* Venkata Phani Kiran Achanta <neo_phani@hotmail.com>, and
* Norbert E. Gruener <nog@MPA-Garching.MPG.de>
* 2001-2002: Norbert E. Gruener <nog@MPA-Garching.MPG.de>
*
* The original library was written by Roland Schemers <schemers@slapshot.stanford.edu>
* and is covered by the following copyright:
*
* Copyright (c) 1994 Board of Trustees, Leland Stanford Jr. University
* For conditions of distribution and use, see the copyright notice in
* the Stanford-LICENCE file.
*
* The code for the original library were mainly taken from the AFS
* source distribution, which comes with this message:
*
* Copyright (C) 1989-1994 Transarc Corporation - All rights reserved
* P_R_P_Q_# (C) COPYRIGHT IBM CORPORATION 1987, 1988, 1989
*
***********************************************************************/
#include "EXTERN.h"
#ifdef __sgi /* needed to get a clean compile */
#include <setjmp.h>
#endif
#include "perl.h"
#include "XSUB.h"
#define NEED_newRV_noinc
#define NEED_sv_2pv_flags
#include "ppport.h"
#include <afs/param.h>
/* tired of seeing messages about TRUE/FALSE being redefined in rx/xdr.h */
#undef TRUE
#undef FALSE
#include <rx/xdr.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/stat.h>
#undef INIT
#include <afs/stds.h>
#include <afs/afs.h>
#include <afs/vice.h>
#include <afs/venus.h>
#undef VIRTUE
#undef VICE
#include <afs/prs_fs.h>
#include <afs/afsint.h>
#include <afs/auth.h>
#include <afs/cellconfig.h>
#if defined(AFS_3_4)
#else
#include <afs/dirpath.h>
#endif
#include <ubik.h>
#include <rx/rxkad.h>
#include <afs/vldbint.h>
#include <afs/volser.h>
#ifndef RV_RDONLY
#define RV_FULLRST 0x000001
#define RV_OFFLINE 0x000002
#define RV_CRDUMP 0x000010
#define RV_CRKEEP 0x000020
#define RV_CRNEW 0x000040
#define RV_LUDUMP 0x000100
#define RV_LUKEEP 0x000200
#define RV_LUNEW 0x000400
#define RV_RDONLY 0x010000
#define RV_CPINCR 0x020000
#define RV_NOVLDB 0x040000
#define RV_NOCLONE 0x080000
#define RV_NODEL 0x100000
#endif
#include <afs/vlserver.h>
#include <afs/volint.h>
#include <afs/cmd.h>
#include <afs/usd.h>
#include <afs/ptclient.h>
#include <afs/pterror.h>
#include <afs/print.h>
#include <afs/kauth.h>
#include <afs/kautils.h>
#include <afs/bosint.h>
#include <afs/bnode.h>
#include <afs/ktime.h>
#if defined(AFS_OLD_COM_ERR)
#include <com_err.h>
#else
#include <afs/com_err.h>
#endif
#include <des.h>
#if defined(AFS_3_4) || defined(AFS_3_5)
#else
#define int32 afs_int32
#define uint32 afs_uint32
#endif
const char *const xs_version = "AFS.xs (Version 2.6.4)";
/* here because it seemed too painful to #define KERNEL before #inc afs.h */
struct VenusFid {
int32 Cell;
struct AFSFid Fid;
};
/* tpf nog 03/29/99 */
/* the following was added by leg@andrew, 10/9/96 */
/*#ifdef __hpux*//* only on hp700_ux90 systems */
#if defined(__hpux) || defined(_AIX) || defined(sun) || defined(__sun__) || defined(__sgi) || defined(__linux)
static int32 name_is_numeric(char *);
#endif
typedef SV *AFS__ACL;
typedef struct ktc_principal *AFS__KTC_PRINCIPAL;
typedef struct ktc_token *AFS__KTC_TOKEN;
typedef struct ktc_encryptionKey *AFS__KTC_EKEY;
typedef struct ubik_client *AFS__KAS;
typedef struct ubik_client *AFS__PTS;
typedef struct ubik_client *AFS__VLDB;
typedef struct ubik_client *AFS__VOS;
typedef struct rx_connection *AFS__BOS;
extern struct ubik_client *cstruct;
#include "afs_prototypes.h"
extern int afs_setpag();
static rxkad_level vsu_rxkad_level = rxkad_clear;
static struct ktc_token the_null_token;
static int32 convert_numeric_names = 1;
static int32 rx_initialized = 0;
#define MAXSIZE 2048
#define MAXINSIZE 1300
#ifndef MAXPATHLEN
#define MAXPATHLEN 1024
#endif
#define AFS_ASK 0
#define AFS_ABORT 1
#define AFS_FULL 2
#define AFS_INC 3
#ifdef AFS_PTHREAD_ENV
#undef clock_haveCurrentTime
#undef clock_UpdateTime
struct clock clock_now;
#endif /* AFS_PTHREAD_ENV*/
/* error handling macros */
#define ERROR_EXIT(code) {error=(code); goto error_exit;}
#define SETCODE(code) set_code(code)
#define BSETCODE(code, msg) bv_set_code(code, msg)
#define VSETCODE(code, msg) bv_set_code(code, msg)
#define KSETCODE(code, msg) k_set_code(code, msg)
#define PSETCODE(msg) p_set_code(msg)
static int32 raise_exception = 0;
void safe_hv_store (HV* ahv,char * key ,int i ,SV * asv,int j) {
if (! hv_store(ahv, key, i, asv, j)) {
fprintf(stderr,"Panic ... internal error. hv_store failed.\n");
exit(1);
}
return;
}
static void bv_set_code(code, msg)
int32 code;
const char *msg;
{
SV *sv = get_sv("AFS::CODE", TRUE);
sv_setiv(sv, (IV) code);
/* printf("BV_SET_CODE %s (%d)\n", msg, code); */
if (code == 0) {
sv_setpv(sv, "");
}
else {
if (raise_exception) {
char buffer[1024];
sprintf(buffer, "AFS exception: %s (%d)", msg, code);
croak(buffer);
}
/* printf("BV_SET_CODE %s (%d)\n", msg, code); */
sv_setpv(sv, (char *) msg);
}
SvIOK_on(sv);
}
static void p_set_code(msg)
const char *msg;
{
int32 code = errno;
SV *sv = get_sv("AFS::CODE", TRUE);
sv_setiv(sv, (IV) code);
/* printf("P_SET_CODE %s (%d)\n", msg, code); */
if (code == 0) {
sv_setpv(sv, "");
}
else {
char buffer[1024];
if (raise_exception) {
sprintf(buffer, "AFS exception: %s (%s) (%d)", msg, error_message(code), code);
croak(buffer);
}
/* printf("P_SET_CODE %s (%d)\n", msg, code); */
sprintf(buffer, "%s: %s (%d)", msg, error_message(code), code);
sv_setpv(sv, buffer);
}
SvIOK_on(sv);
}
static void k_set_code(code, msg)
int32 code;
const char *msg;
{
SV *sv = get_sv("AFS::CODE", TRUE);
sv_setiv(sv, (IV) code);
/* printf("K_SET_CODE %s (%d)\n", msg, code); */
if (code == 0) {
sv_setpv(sv, "");
}
else {
char buffer[1024];
if (raise_exception) {
sprintf(buffer, "AFS exception: %s (%s) (%d)", msg, error_message(code), code);
croak(buffer);
}
/* printf("K_SET_CODE %s (%d)\n", msg, code); */
sprintf(buffer, "%s: %s (%d)", msg, error_message(code), code);
sv_setpv(sv, buffer);
}
SvIOK_on(sv);
}
static void set_code(code)
int32 code;
{
SV *sv = get_sv("AFS::CODE", TRUE);
if (code == -1) { code = errno; }
/* printf("SET_CODE %d\n", code); */
sv_setiv(sv, (IV) code);
if (code == 0) {
sv_setpv(sv, "");
}
else {
if (raise_exception) {
char buffer[1024];
sprintf(buffer, "AFS exception: %s (%d)", error_message(code), code);
croak(buffer);
}
sv_setpv(sv, (char *) error_message(code));
}
SvIOK_on(sv);
}
/* taken from openafs-1.2.9 */
/* volser/vsprocs.c */
int set_errbuff(buffer, errcode)
char *buffer;
int32 errcode;
{
/*replace by a big switch statement */
switch (errcode) {
case 0:
break;
case -1:
sprintf(buffer, "Possible communication failure\n");
break;
case VSALVAGE:
sprintf(buffer, "Volume needs to be salvaged\n");
break;
case VNOVNODE:
sprintf(buffer, "Bad vnode number quoted\n");
break;
case VNOVOL:
sprintf(buffer, "Volume not attached, does not exist, or not on line\n");
break;
case VVOLEXISTS:
sprintf(buffer, "Volume already exists\n");
break;
case VNOSERVICE:
sprintf(buffer, "Volume is not in service\n");
break;
case VOFFLINE:
sprintf(buffer, "Volume is off line\n");
break;
case VONLINE:
sprintf(buffer, "Volume is already on line\n");
break;
case VDISKFULL:
sprintf(buffer, "Partition is full\n");
break;
case VOVERQUOTA:
sprintf(buffer, "Volume max quota exceeded\n");
break;
case VBUSY:
sprintf(buffer, "Volume temporarily unavailable\n");
break;
case VMOVED:
sprintf(buffer, "Volume has moved to another server\n");
break;
case VL_IDEXIST:
sprintf(buffer, "VLDB: volume Id exists in the vldb\n");
break;
case VL_IO:
sprintf(buffer, "VLDB: a read terminated too early\n");
break;
case VL_NAMEEXIST:
sprintf(buffer, "VLDB: volume entry exists in the vldb\n");
break;
case VL_CREATEFAIL:
sprintf(buffer, "VLDB: internal creation failure\n");
break;
case VL_NOENT:
sprintf(buffer, "VLDB: no such entry\n");
break;
case VL_EMPTY:
sprintf(buffer, "VLDB: vldb database is empty\n");
break;
case VL_ENTDELETED:
sprintf(buffer, "VLDB: entry is deleted (soft delete)\n");
break;
case VL_BADNAME:
sprintf(buffer, "VLDB: no such repsite server exists\n");
break;
case VL_DUPREPSERVER:
sprintf(buffer, "VLDB: replication site server already exists\n");
break;
case VL_RWNOTFOUND:
sprintf(buffer, "VLDB: parent r/w entry not found\n");
break;
case VL_BADREFCOUNT:
sprintf(buffer, "VLDB: illegal reference count number\n");
break;
case VL_SIZEEXCEEDED:
sprintf(buffer, "VLDB: vldb size for attributes exceeded\n");
break;
case VL_BADENTRY:
sprintf(buffer, "VLDB: bad incoming vldb entry\n");
break;
case VL_BADVOLIDBUMP:
sprintf(buffer, "VLDB: illegal max volid increment\n");
break;
case VL_IDALREADYHASHED:
sprintf(buffer, "VLDB: (RO/BACK) Id already hashed\n");
break;
case VL_ENTRYLOCKED:
sprintf(buffer, "VLDB: vldb entry is already locked\n");
break;
case VL_BADVOLOPER:
sprintf(buffer, "VLDB: bad volume operation code\n");
break;
case VL_BADRELLOCKTYPE:
sprintf(buffer, "VLDB: bad release lock type\n");
break;
case VL_RERELEASE:
sprintf(buffer, "VLDB: status report: last release was aborted\n");
break;
case VL_BADSERVERFLAG:
sprintf(buffer, "VLDB: invalid replication site server flag\n");
break;
case VL_PERM:
sprintf(buffer, "VLDB: no permission access for call\n");
break;
case VOLSERREAD_DUMPERROR:
sprintf(buffer, "VOLSER: Problems encountered in reading the dump file !\n");
break;
case VOLSERDUMPERROR:
sprintf(buffer, "VOLSER: Problems encountered in doing the dump !\n");
break;
case VOLSERATTACH_ERROR:
sprintf(buffer, "VOLSER: Could not attach the volume\n");
break;
case VOLSERDETACH_ERROR:
sprintf(buffer, "VOLSER: Could not detach the volume\n");
break;
case VOLSERILLEGAL_PARTITION:
sprintf(buffer, "VOLSER: encountered illegal partition number\n");
break;
case VOLSERBAD_ACCESS:
sprintf(buffer, "VOLSER: permission denied, not a super user\n");
break;
case VOLSERVLDB_ERROR:
sprintf(buffer, "VOLSER: error detected in the VLDB\n");
break;
case VOLSERBADNAME:
sprintf(buffer, "VOLSER: error in volume name\n");
break;
case VOLSERVOLMOVED:
sprintf(buffer, "VOLSER: volume has moved\n");
break;
case VOLSERBADOP:
sprintf(buffer, "VOLSER: illegal operation\n");
break;
case VOLSERBADRELEASE:
sprintf(buffer, "VOLSER: release could not be completed\n");
break;
case VOLSERVOLBUSY:
sprintf(buffer, "VOLSER: volume is busy\n");
break;
case VOLSERNO_MEMORY:
sprintf(buffer, "VOLSER: volume server is out of memory\n");
break;
case VOLSERNOVOL:
sprintf(buffer,
"VOLSER: no such volume - location specified incorrectly or volume does not exist\n");
break;
case VOLSERMULTIRWVOL:
sprintf(buffer,
"VOLSER: multiple RW volumes with same ID, one of which should be deleted\n");
break;
case VOLSERFAILEDOP:
sprintf(buffer, "VOLSER: not all entries were successfully processed\n");
break;
default:
sprintf(buffer, "Unknown ERROR code\n");
break;
}
return 0;
}
#ifdef AFS_PTHREAD_ENV
void IOMGR_Sleep (seconds)
int seconds;
{
double i,j;
croak("DEBUG: IOMGR_Sleep not available ...\nPlease inform the author...");
j = 0.0;
i = 1.0/j;
}
void clock_UpdateTime ()
{
double i,j;
croak("DEBUG: clock_UpdateTime not available ...\nPlease inform the author.. .");
j = 0.0;
i = 1.0/j;
}
int clock_haveCurrentTime ()
{
double i,j;
croak("DEBUG: clock_haveCurrentTime not available...\nPlease inform the auth or...");
j = 0.0;
i = 1.0/j;
return 1;
}
#endif /* AFS_PTHREAD_ENV*/
static int32 not_here(s)
char *s;
{
croak("%s not implemented on this architecture or under this AFS version", s);
return -1;
}
int PrintDiagnostics(astring, acode)
char *astring;
afs_int32 acode;
{
if (acode == EACCES) {
fprintf(STDERR, "You are not authorized to perform the 'vos %s' command (%d)\n",
astring, acode);
}
else {
fprintf(STDERR, "Error in vos %s command.\n", astring);
PrintError("", acode);
}
return 0;
}
/* end of error handling macros */
/* general helper functions */
static struct afsconf_dir *cdir = NULL;
static char *config_dir = NULL;
static int32 internal_GetConfigDir()
{
if (cdir == NULL) {
if (config_dir == NULL) {
#if defined(AFS_3_4)
config_dir = (char *) safemalloc(strlen(AFSCONF_CLIENTNAME) + 1);
strcpy(config_dir, AFSCONF_CLIENTNAME);
#else
config_dir = (char *) safemalloc(strlen(AFSDIR_CLIENT_ETC_DIRPATH) + 1);
strcpy(config_dir, AFSDIR_CLIENT_ETC_DIRPATH);
#endif
}
cdir = afsconf_Open(config_dir);
if (!cdir) {
char buffer[256];
sprintf(buffer, "GetConfigDir: Can't open configuration directory (%s)", config_dir);
PSETCODE(buffer);
return errno;
}
}
return 0;
}
static int32 internal_GetServerConfigDir()
{
if (cdir == NULL) {
if (config_dir == NULL) {
#if defined(AFS_3_4)
config_dir = (char *) safemalloc(strlen(AFSCONF_SERVERNAME) + 1);
strcpy(config_dir, AFSCONF_SERVERNAME);
#else
config_dir = (char *) safemalloc(strlen(AFSDIR_SERVER_ETC_DIRPATH) + 1);
strcpy(config_dir, AFSDIR_SERVER_ETC_DIRPATH);
#endif
}
cdir = afsconf_Open(config_dir);
if (!cdir) {
char buffer[256];
sprintf(buffer, "GetServerConfigDir: Can't open configuration directory (%s)", config_dir);
PSETCODE(buffer);
return errno;
}
}
return 0;
}
static int32 internal_GetCellInfo(cell, service, info)
char *cell;
char *service;
struct afsconf_cell *info;
{
int32 code;
code = internal_GetConfigDir();
if (code == 0) {
code = afsconf_GetCellInfo(cdir, cell, service, info);
if (code) {
char buffer[256];
sprintf(buffer, "GetCellInfo: ");
KSETCODE(code, buffer);
}
}
return code;
}
static char *internal_GetLocalCell(code)
int32 *code;
{
static char localcell[MAXCELLCHARS] = "";
if (localcell[0]) {
*code = 0;
}
else {
*code = internal_GetConfigDir();
if (*code)
return NULL;
*code = afsconf_GetLocalCell(cdir, localcell, sizeof(localcell));
if (*code) {
char buffer[256];
sprintf(buffer, "GetLocalCell: Can't determine local cell name");
PSETCODE(buffer);
return NULL;
}
}
return localcell;
}
static void stolower(s)
char *s;
{
while (*s) {
if (isupper(*s))
*s = tolower(*s);
s++;
}
}
/* return 1 if name is all '-' or digits. Used to remove orphan
entries from ACls */
safe_hv_store(stats, "reserved4", 9, newSViv(entry->reserved[4]), 0);
return 1;
}
static int32 check_name_for_id(name, id)
char *name;
int32 id;
{
char buff[32];
sprintf(buff, "%d", id);
return strcmp(buff, name) == 0;
}
/* end of helper functions for PTS class: */
/* helper functions for VOS && VLDB class: */
/* copy taken from <src/util/regex.c> OpenAFS-1.4.14.1 */
/*
* constants for re's
*/
#define CBRA 1
#define CCHR 2
#define CDOT 4
#define CCL 6
#define NCCL 8
#define CDOL 10
#define CEOF 11
#define CKET 12
#define CBACK 18
#define CSTAR 01
#define ESIZE 512
#define NBRA 9
static char expbuf[ESIZE], *braslist[NBRA], *braelist[NBRA];
static char circf;
/* forward defs
*/
static int advance(register char *lp, register char *ep);
static int backref(register int i, register char *lp);
static int cclass(register char *set, register char c, int af);
/*
* compile the regular expression argument into a dfa
*/
char *
re_comp(register char *sp)
{
register int c;
register char *ep = expbuf;
int cclcnt, numbra = 0;
char *lastep = 0;
char bracket[NBRA];
char *bracketp = &bracket[0];
static char *retoolong = "Regular expression too long";
#define comperr(msg) {expbuf[0] = 0; numbra = 0; return(msg); }
if (sp == 0 || *sp == '\0') {
if (*ep == 0)
return ("No previous regular expression");
return (0);
}
if (*sp == '^') {
circf = 1;
sp++;
} else
circf = 0;
for (;;) {
if (ep >= &expbuf[ESIZE - 10 /* fudge factor */])
comperr(retoolong);
if ((c = *sp++) == '\0') {
if (bracketp != bracket)
comperr("unmatched \\(");
*ep++ = CEOF;
*ep++ = 0;
return (0);
}
if (c != '*')
lastep = ep;
switch (c) {
case '.':
*ep++ = CDOT;
continue;
case '*':
if (lastep == 0 || *lastep == CBRA || *lastep == CKET)
goto defchar;
*lastep |= CSTAR;
continue;
case '$':
if (*sp != '\0')
goto defchar;
*ep++ = CDOL;
continue;
case '[':
*ep++ = CCL;
*ep++ = 0;
cclcnt = 1;
if ((c = *sp++) == '^') {
c = *sp++;
ep[-2] = NCCL;
}
do {
if (c == '\0')
comperr("missing ]");
if (c == '-' && ep[-1] != 0) {
if ((c = *sp++) == ']') {
*ep++ = '-';
cclcnt++;
break;
}
while (ep[-1] < c) {
*ep = ep[-1] + 1;
ep++;
cclcnt++;
if (ep >= &expbuf[ESIZE - 10 /* fudge factor */])
comperr(retoolong);
}
}
*ep++ = c;
cclcnt++;
if (ep >= &expbuf[ESIZE - 10 /* fudge factor */])
comperr(retoolong);
} while ((c = *sp++) != ']');
lastep[1] = cclcnt;
continue;
case '\\':
if ((c = *sp++) == '(') {
if (numbra >= NBRA)
comperr("too many \\(\\) pairs");
*bracketp++ = numbra;
*ep++ = CBRA;
*ep++ = numbra++;
continue;
}
if (c == ')') {
if (bracketp <= bracket)
comperr("unmatched \\)");
*ep++ = CKET;
*ep++ = *--bracketp;
continue;
}
if (c >= '1' && c < ('1' + NBRA)) {
*ep++ = CBACK;
*ep++ = c - '1';
continue;
}
*ep++ = CCHR;
*ep++ = c;
continue;
defchar:
default:
*ep++ = CCHR;
*ep++ = c;
}
}
}
/*
* match the argument string against the compiled re
*/
int
re_exec(register char *p1)
{
register char *p2 = expbuf;
register int c;
int rv;
for (c = 0; c < NBRA; c++) {
braslist[c] = 0;
braelist[c] = 0;
}
if (circf)
return ((advance(p1, p2)));
/*
* fast check for first character
*/
if (*p2 == CCHR) {
c = p2[1];
do {
if (*p1 != c)
continue;
if ((rv = advance(p1, p2)))
return (rv);
} while (*p1++);
return (0);
}
/*
* regular algorithm
*/
do
if ((rv = advance(p1, p2)))
return (rv);
while (*p1++);
return (0);
}
char buffer[256];
sprintf(buffer,
"%s: Could not get security object for -localAuth\n",
funcName);
VSETCODE(code, buffer);
return (code);
}
code = afsconf_GetCellInfo(tdir, tdir->cellName, serviceid, &info);
if (code) {
afsconf_Close(tdir);
char buffer[256];
sprintf(buffer,
"%s: can't find cell %s's hosts in %s/%s\n",
funcName, cellName, AFSDIR_SERVER_ETC_DIRPATH,
AFSDIR_CELLSERVDB_FILE);
VSETCODE(code, buffer);
return (code);
}
} else { /* not -localauth */
tdir = afsconf_Open(confDir);
if (!tdir) {
char buffer[256];
sprintf(buffer,
"%s: Could not process files in configuration directory (%s).\n",
funcName, confDir);
code = -1;
VSETCODE(code, buffer);
return (code);
}
if (!cellName) {
code = afsconf_GetLocalCell(tdir, cellstr, sizeof(cellstr));
if (code) {
char buffer[256];
sprintf(buffer,
"%s: can't get local cellname, check %s/%s\n",
funcName, confDir, AFSDIR_THISCELL_FILE);
VSETCODE(code, buffer);
return (code);
}
cellName = cellstr;
}
code = afsconf_GetCellInfo(tdir, cellName, serviceid, &info);
if (code) {
char buffer[256];
sprintf(buffer,
"%s: can't find cell %s's hosts in %s/%s\n",
funcName, cellName, confDir, AFSDIR_CELLSERVDB_FILE);
VSETCODE(code, buffer);
return (code);
}
if (noAuthFlag) /* -noauth */
scIndex = 0;
else { /* not -noauth */
strcpy(sname.cell, info.name);
sname.instance[0] = 0;
strcpy(sname.name, "afs");
code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
if (code) { /* did not get ticket */
fprintf(stderr,
"%s: Could not get afs tokens, running unauthenticated.\n",
funcName);
scIndex = 0;
} else { /* got a ticket */
scIndex = 2;
if ((ttoken.kvno < 0) || (ttoken.kvno > 256)) {
fprintf(stderr,
"%s: funny kvno (%d) in ticket, proceeding\n",
funcName, ttoken.kvno);
}
}
}
char buffer[256];
switch (scIndex) {
case 0:
sc = rxnull_NewClientSecurityObject();
break;
case 2:
sc = rxkad_NewClientSecurityObject(gen_rxkad_level,
&ttoken.sessionKey,
ttoken.kvno, ttoken.ticketLen,
ttoken.ticket);
break;
default:
sprintf(buffer, "%s: unsupported security index %d\n",
funcName, scIndex);
code = 1;
VSETCODE(code, buffer);
return (code);
break;
}
}
afsconf_Close(tdir);
if (secproc) /* tell UV module about default authentication */
(*secproc) (sc, scIndex);
if (server) {
serverconns[0] = rx_NewConnection(server, port,
usrvid, sc, scIndex);
} else {
if (info.numServers > maxservers) {
char buffer[256];
sprintf(buffer,
"%s: info.numServers=%d (> maxservers=%d)\n",
funcName, info.numServers, maxservers);
code = 1;
VSETCODE(code, buffer);
return (code);
}
for (i = 0; i < info.numServers; i++) {
serverconns[i] =
rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
info.hostAddr[i].sin_port, usrvid,
sc, scIndex);
}
}
/* Are we just setting up connections, or is this really ubik stuff? */
if (uclientp) {
*uclientp = 0;
code = ubik_ClientInit(serverconns, uclientp);
if (code) {
char buffer[256];
sprintf(buffer, "%s: ubik client init failed.\n", funcName);
VSETCODE(code, buffer);
return (code);
success = 0;
*code = 0;
*code = UV_ListPartitions(server, &dummyPartList, &cnt);
if (*code)
return success;
for (i = 0; i < cnt; i++) {
if (dummyPartList.partFlags[i] & PARTVALID)
if (dummyPartList.partId[i] == partId)
success = 1;
}
return success;
}
afs_int32 GetServer(aname)
char *aname;
{
register struct hostent *th;
afs_int32 addr;
int b1, b2, b3, b4;
register afs_int32 code;
char hostname[MAXHOSTCHARS];
code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
if (code == 4) {
addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
addr = ntohl(addr); /* convert to host order */
}
else {
th = gethostbyname(aname);
if (!th)
return 0;
/* memcpy(&addr, th->h_addr, sizeof(addr)); */
Copy(th->h_addr, &addr, th->h_length, char);
}
if (addr == htonl(0x7f000001)) { /* local host */
code = gethostname(hostname, MAXHOSTCHARS);
if (code)
return 0;
th = gethostbyname(hostname); /* returns host byte order */
if (!th)
return 0;
/* memcpy(&addr, th->h_addr, sizeof(addr)); */
Copy(th->h_addr, &addr, th->h_length, char);
}
return (addr);
}
/*sends the contents of file associated with <fd> and <blksize> to Rx Stream
* associated with <call> */
int SendFile(ufd, call, blksize)
usd_handle_t ufd;
register struct rx_call *call;
long blksize;
{
char *buffer = (char *) 0;
afs_int32 error = 0;
int done = 0;
afs_uint32 nbytes;
buffer = (char *) safemalloc(blksize);
if (!buffer) {
char buf[256];
sprintf(buf, "malloc failed\n");
VSETCODE(-1, buf);
return -1;
}
while (!error && !done) {
#ifndef AFS_NT40_ENV /* NT csn't select on non-socket fd's */
fd_set in;
FD_ZERO(&in);
FD_SET((long) (ufd->handle), &in);
/* don't timeout if read blocks */
#ifdef AFS_PTHREAD_ENV
select(((long) (ufd->handle)) + 1, &in, 0, 0, 0);
#else
IOMGR_Select(((long) (ufd->handle)) + 1, &in, 0, 0, 0);
#endif /* AFS_PTHREAD_ENV*/
#endif
error = USD_READ(ufd, buffer, blksize, &nbytes);
if (error) {
char buf[256];
sprintf(buf, "File system read failed\n");
VSETCODE(error, buf);
break;
}
if (nbytes == 0) {
done = 1;
break;
}
if (rx_Write(call, buffer, nbytes) != nbytes) {
error = -1;
break;
}
}
if (buffer)
free(buffer);
return error;
}
/* function invoked by UV_RestoreVolume, reads the data from rx_trx_stream and
* writes it out to the volume. */
afs_int32 WriteData(call, rock)
struct rx_call *call;
char *rock;
{
char *filename;
usd_handle_t ufd;
long blksize;
afs_int32 error, code;
int ufdIsOpen = 0;
error = 0;
filename = rock;
if (!filename || !*filename) {
usd_StandardInput(&ufd);
blksize = 4096;
ufdIsOpen = 1;
}
else {
code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
if (code == 0) {
ufdIsOpen = 1;
code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
}
if (code) {
char buffer[256];
sprintf(buffer, "Could not access file '%s'\n", filename);
error = VOLSERBADOP;
VSETCODE(error, buffer);
goto wfail;
}
}
code = SendFile(ufd, call, blksize);
if (code) {
error = code;
goto wfail;
}
wfail:
if (ufdIsOpen) {
code = USD_CLOSE(ufd);
if (code) {
char buffer[256];
sprintf(buffer, "Could not close dump file %s\n",
(filename && *filename) ? filename : "STDOUT");
VSETCODE(code, buffer);
if (!error)
error = code;
}
}
return error;
}
/* Receive data from <call> stream into file associated
* with <fd> <blksize>
*/
int ReceiveFile(ufd, call, blksize)
usd_handle_t ufd;
struct rx_call *call;
long blksize;
{
char *buffer = (char *) 0;
afs_int32 bytesread;
afs_uint32 bytesleft, w;
afs_int32 error = 0;
buffer = (char *) safemalloc(blksize);
if (!buffer) {
char buf[256];
sprintf(buf, "memory allocation failed\n");
VSETCODE(-1, buf);
ERROR_EXIT(-1);
}
while ((bytesread = rx_Read(call, buffer, blksize)) > 0) {
for (bytesleft = bytesread; bytesleft; bytesleft -= w) {
#ifndef AFS_NT40_ENV /* NT csn't select on non-socket fd's */
fd_set out;
FD_ZERO(&out);
FD_SET((long) (ufd->handle), &out);
/* don't timeout if write blocks */
#ifdef AFS_PTHREAD_ENV
select(((long) (ufd->handle)) + 1, 0, &out, 0, 0);
#else
IOMGR_Select(((long) (ufd->handle)) + 1, 0, &out, 0, 0);
#endif /* AFS_PTHREAD_ENV*/
#endif
error = USD_WRITE(ufd, &buffer[bytesread - bytesleft], bytesleft, &w);
if (error) {
char buf[256];
sprintf(buf, "File system write failed\n");
VSETCODE(-1, buf);
ERROR_EXIT(-1);
}
}
}
error_exit:
if (buffer)
free(buffer);
return (error);
}
afs_int32 DumpFunction(call, filename)
struct rx_call *call;
char *filename;
{
usd_handle_t ufd; /* default is to stdout */
afs_int32 error = 0, code;
afs_hyper_t size;
long blksize;
int ufdIsOpen = 0;
/* Open the output file */
if (!filename || !*filename) {
usd_StandardOutput(&ufd);
blksize = 4096;
ufdIsOpen = 1;
}
else {
code = usd_Open(filename, USD_OPEN_CREATE | USD_OPEN_RDWR, 0666, &ufd);
if (code == 0) {
ufdIsOpen = 1;
hzero(size);
code = USD_IOCTL(ufd, USD_IOCTL_SETSIZE, &size);
}
if (code == 0) {
code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
}
if (code) {
char buffer[256];
sprintf(buffer, "Could not create file '%s'\n", filename);
VSETCODE(VOLSERBADOP, buffer);
ERROR_EXIT(VOLSERBADOP);
}
}
code = ReceiveFile(ufd, call, blksize);
if (code)
ERROR_EXIT(code);
error_exit:
/* Close the output file */
if (ufdIsOpen) {
code = USD_CLOSE(ufd);
if (code) {
char buffer[256];
sprintf(buffer, "Could not close dump file %s\n",
(filename && *filename) ? filename : "STDIN");
VSETCODE(code, buffer);
if (!error)
error = code;
}
}
return (error);
}
struct tqElem {
afs_int32 volid;
struct tqElem *next;
};
struct tqHead {
afs_int32 count;
struct tqElem *next;
};
static struct tqHead busyHead, notokHead;
static void qInit(ahead)
struct tqHead *ahead;
{
Zero(ahead, 1, struct tqHead);
return;
}
static void qPut(ahead, volid)
struct tqHead *ahead;
afs_int32 volid;
{
struct tqElem *elem;
elem = (struct tqElem *) safemalloc(sizeof(struct tqElem));
elem->next = ahead->next;
elem->volid = volid;
ahead->next = elem;
ahead->count++;
return;
}
/* Kann vielleicht ganz raus ??? */
/* static void qGet(ahead, volid) */
/* struct tqHead *ahead; */
/* afs_int32 *volid; */
/* { */
/* struct tqElem *tmp; */
/* if (ahead->count <= 0) */
/* return; */
/* *volid = ahead->next->volid; */
/* tmp = ahead->next; */
/* ahead->next = tmp->next; */
/* ahead->count--; */
/* free(tmp); */
/* return; */
/* } */
static int FileExists(filename)
char *filename;
{
usd_handle_t ufd;
int code;
afs_hyper_t size;
code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
return ac - '0';
if (ac >= 'a' && ac <= 'f')
return ac - 'a' + 10;
if (ac >= 'A' && ac <= 'F')
return ac - 'A' + 10;
return 0;
}
afs_uint32 GetUInt32(as, aval)
register char *as;
afs_uint32 *aval;
{
register afs_uint32 total;
register int tc;
int base;
total = 0; /* initialize things */
/* skip over leading spaces */
while ((tc = *as)) {
if (tc != ' ' && tc != '\t')
break;
}
/* compute the base */
if (*as == '0') {
as++;
if (*as == 'x' || *as == 'X') {
base = 16;
as++;
}
else
base = 8;
}
else
base = 10;
/* compute the # itself */
while ((tc = *as)) {
if (!ismeta(tc, base))
return -1;
total *= base;
total += getmeta(tc);
as++;
}
*aval = total;
return 0;
}
#endif
/* keep those lines small */
static char *em(acode)
afs_int32 acode;
{
if (acode == -1)
return "communications failure (-1)";
else if (acode == -3)
return "communications timeout (-3)";
else
return (char *) error_message(acode);
}
static struct rx_connection *internal_bos_new(code, hostname, localauth, noauth, aencrypt,
tname)
int32 *code;
char *hostname;
int localauth;
int noauth;
int aencrypt;
char *tname;
{
struct hostent *th;
register struct rx_connection *tconn;
struct rx_securityClass *sc[3];
int scIndex;
afs_int32 addr;
int encryptLevel;
struct ktc_principal sname;
struct ktc_token ttoken;
/* printf("bos DEBUG-1: %s \n", cdir); */
th = (struct hostent *) hostutil_GetHostByName(hostname);
if (!th) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't find address for host '%s'\n", hostname);
*code = -1;
BSETCODE(code, buffer);
/* printf("bos DEBUG-1: %s\n", buffer); */
return NULL;
}
/* Copy(th->h_addr, &addr, sizeof(afs_int32), afs_int32); */
Copy(th->h_addr, &addr, th->h_length, char);
/* get tokens for making authenticated connections */
if (!rx_initialized) {
/* printf("bos DEBUG rx_Init\n"); */
*code = rx_Init(0);
if (*code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: could not initialize rx (%d)\n", *code);
BSETCODE(code, buffer);
/* printf("bos DEBUG-2\n"); */
return NULL;
}
}
rx_initialized = 1;
*code = ka_Init(0);
if (*code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: could not initialize ka (%d)\n", *code);
BSETCODE(code, buffer);
/* printf("bos DEBUG-3\n"); */
return NULL;
}
if (localauth)
internal_GetServerConfigDir();
else
internal_GetConfigDir();
/* printf("bos DEBUG-2: %s\n", cdir->name); */
if (!cdir) {
*code = errno;
SETCODE(code);
/* printf("bos DEBUG-4\n"); */
return NULL;
}
struct afsconf_cell info;
/* next call expands cell name abbrevs for us and handles looking up
* local cell */
*code = internal_GetCellInfo(tname, (char *) 0, &info);
if (*code) {
char buffer[256];
sprintf(buffer, "AFS::BOS %d (can't find cell '%s' in cell database)",
*code, (tname ? tname : "<default>"));
BSETCODE(code, buffer);
/* printf("bos DEBUG-5\n"); */
return NULL;
}
strcpy(sname.cell, info.name);
sname.instance[0] = 0;
strcpy(sname.name, "afs");
sc[0] = (struct rx_securityClass *) rxnull_NewClientSecurityObject();
sc[1] = 0;
sc[2] = (struct rx_securityClass *) NULL;
scIndex = 0;
if (!noauth) { /* not -noauth */
if (localauth) { /* -localauth */
*code = afsconf_GetLatestKey(cdir, 0, 0);
if (*code)
fprintf(stderr, "AFS::BOS %d (getting key from local KeyFile)", *code);
else {
if (aencrypt)
*code = afsconf_ClientAuthSecure(cdir, &sc[2], &scIndex);
else
*code = afsconf_ClientAuth(cdir, &sc[2], &scIndex);
if (*code)
fprintf(stderr, "AFS::BOS %d (calling ClientAuth)", *code);
else if (scIndex != 2) /* this shouldn't happen */
sc[scIndex] = sc[2];
}
}
else { /* not -localauth, check for tickets */
*code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
if (*code == 0) {
/* have tickets, will travel */
if (ttoken.kvno >= 0 && ttoken.kvno <= 256);
else {
fprintf(stderr,
"AFS::BOS: funny kvno (%d) in ticket, proceeding\n",
ttoken.kvno);
}
/* kerberos tix */
if (aencrypt)
encryptLevel = rxkad_crypt;
else
encryptLevel = rxkad_clear;
sc[2] = (struct rx_securityClass *)
rxkad_NewClientSecurityObject
(encryptLevel, &ttoken.sessionKey,
ttoken.kvno, ttoken.ticketLen, ttoken.ticket);
scIndex = 2;
}
else
fprintf(stderr, "AFS::BOS %d (getting tickets)", *code);
}
if ((scIndex == 0) || (sc[scIndex] == 0)) {
fprintf(stderr, "AFS::BOS: running unauthenticated\n");
scIndex = 0;
}
}
tconn = rx_NewConnection(addr, htons(AFSCONF_NANNYPORT), 1, sc[scIndex], scIndex);
if (!tconn) {
char buffer[256];
sprintf(buffer, "AFS::BOS: could not create rx connection\n");
*code = -1;
BSETCODE(code, buffer);
/* printf("bos DEBUG-7\n"); */
return NULL;
}
rxs_Release(sc[scIndex]);
return tconn;
}
static int DoStat(stats, aname, aconn, aint32p, firstTime)
HV *stats;
IN char *aname;
IN register struct rx_connection *aconn;
IN int aint32p;
IN int firstTime; /* true iff first instance in cmd */
{
afs_int32 temp;
char buffer[500];
register afs_int32 code;
register afs_int32 i;
struct bozo_status istatus;
char *tp;
char *is1, *is2, *is3, *is4; /* instance strings */
char info[255];
tp = buffer;
code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
if (code) {
char buf[256];
sprintf(buf, "AFS::BOS: failed to get instance info for '%s' (%s)\n",
aname, em(code));
BSETCODE(code, buf);
return -1;
}
if (firstTime && aint32p && (istatus.flags & BOZO_BADDIRACCESS)) {
char buf[256];
sprintf(buf, "Bosserver reports inappropriate access on server directories\n");
BSETCODE(-1, buf);
}
/*printf("Instance %s, ", aname); */
if (aint32p) {
/* printf("(type is %s) ", buffer); */
safe_hv_store(stats, "type", 4, newSVpv(buffer, strlen(buffer)), 0);
}
sprintf(info, "%s", "");
if (istatus.fileGoal == istatus.goal) {
if (!istatus.goal)
sprintf(info, "%s", "disabled");
}
else {
if (istatus.fileGoal)
sprintf(info, "%s", "temporarily disabled");
else
sprintf(info, "%s", "temporarily enabled");
}
safe_hv_store(stats, "info", 4, newSVpv(info, strlen(info)), 0);
safe_hv_store(stats, "goal", 4, newSViv(istatus.goal), 0);
safe_hv_store(stats, "fileGoal", 8, newSViv(istatus.fileGoal), 0);
if (istatus.flags & BOZO_ERRORSTOP) {
/* printf("stopped for too many errors, "); */
safe_hv_store(stats, "status", 6, newSViv(BOZO_ERRORSTOP), 0);
}
if (istatus.flags & BOZO_HASCORE) {
/* printf("has core file, "); */
safe_hv_store(stats, "status", 6, newSViv(BOZO_HASCORE), 0);
}
safe_hv_store(stats, "flags", 5, newSViv(istatus.flags), 0);
tp = buffer;
code = BOZO_GetStatus(aconn, aname, &temp, &tp);
if (code) {
char buf[256];
sprintf(buf, "AFS::BOS: failed to get status for instance '%s' (%s)\n",
aname, em(code));
BSETCODE(code, buf);
}
else {
/* printf("currently ", aname); */
/* if (temp == BSTAT_NORMAL) printf("running normally.\n"); */
/* else if (temp == BSTAT_SHUTDOWN) printf("shutdown.\n"); */
/* else if (temp == BSTAT_STARTINGUP) printf("starting up.\n"); */
/* else if (temp == BSTAT_SHUTTINGDOWN) printf("shutting down.\n"); */
safe_hv_store(stats, "status", 6, newSViv(temp), 0);
if (buffer[0] != 0) {
/* printf(" Auxiliary status is: %s.\n", buffer); */
safe_hv_store(stats, "aux_status", 10, newSVpv(buffer, strlen(buffer)), 0);
}
}
/* are we done yet? */
if (!aint32p)
return 0;
if (istatus.procStartTime) {
/* printf(" Process last started at %s (%d proc starts)\n", */
/* DateOf(istatus.procStartTime), istatus.procStarts); */
safe_hv_store(stats, "procStartTime", 13, newSViv(istatus.procStartTime), 0);
safe_hv_store(stats, "procStarts", 10, newSViv(istatus.procStarts), 0);
}
if (istatus.lastAnyExit) {
/* printf(" Last exit at %s\n", DateOf(istatus.lastAnyExit)); */
safe_hv_store(stats, "lastAnyExit", 11, newSViv(istatus.lastAnyExit), 0);
}
if (istatus.lastErrorExit) {
is1 = is2 = is3 = is4 = (char *) 0;
/* printf(" Last error exit at %s, ", DateOf(istatus.lastErrorExit)); */
safe_hv_store(stats, "lastErrorExit", 13, newSViv(istatus.lastErrorExit), 0);
code = BOZO_GetInstanceStrings(aconn, aname, &is1, &is2, &is3, &is4);
/* don't complain about failing call, since could simply mean
* interface mismatch.
*/
if (code == 0) {
if (*is1 != 0) {
/* non-null instance string */
/* printf("by %s, ", is1); */
safe_hv_store(stats, "by", 2, newSVpv(is1, strlen(is1)), 0);
}
if (is1)
free(is1);
if (is2)
free(is2);
if (is3)
free(is3);
if (is4)
free(is4);
}
if (istatus.errorSignal) {
/* if (istatus.errorSignal == SIGTERM) */
/* printf("due to shutdown request\n"); */
/* else */
/* printf("due to signal %d\n", istatus.errorSignal); */
safe_hv_store(stats, "errorSignal", 11, newSViv(istatus.errorSignal), 0);
}
else {
/* printf("by exiting with code %d\n", istatus.errorCode); */
safe_hv_store(stats, "errorCode", 9, newSViv(istatus.errorCode), 0);
}
}
if (aint32p > 1) {
AV *av = (AV *) sv_2mortal((SV *) newAV());
/* try to display all the parms */
for (i = 0;; i++) {
tp = buffer;
code = BOZO_GetInstanceParm(aconn, aname, i, &tp);
if (code)
break;
/* fprintf(stderr, " Command %d is '%s'\n", i+1, buffer); */
av_push(av, newSVpv(buffer, strlen(buffer)));
}
safe_hv_store(stats, "command", 7, newRV_inc((SV *) (av)), 0);
tp = buffer;
code = BOZO_GetInstanceParm(aconn, aname, 999, &tp);
if (!code) {
/* Any type of failure is treated as not having a notifier program */
/* printf(" Notifier is '%s'\n", buffer); */
safe_hv_store(stats, "notifier", 8, newSVpv(buffer, strlen(buffer)), 0);
}
/* printf("\n"); */
}
return 0;
}
static afs_int32 GetServerGoal(aconn, aname)
char *aname;
struct rx_connection *aconn;
{
char buffer[500];
char *tp;
register afs_int32 code;
struct bozo_status istatus;
tp = buffer;
code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
if (code) {
printf("AFS::BOS: failed to get instance info for '%s' (%s)\n", aname, em(code));
/* if we can't get the answer, assume its running */
return BSTAT_NORMAL;
}
if (istatus.goal == 0)
return BSTAT_SHUTDOWN;
else
return BSTAT_NORMAL;
}
#define PARMBUFFERSSIZE 32
static struct SalvageParms {
afs_int32 Optdebug;
afs_int32 Optnowrite;
afs_int32 Optforce;
afs_int32 Optoktozap;
afs_int32 Optrootfiles;
afs_int32 Optsalvagedirs;
afs_int32 Optblockreads;
afs_int32 OptListResidencies;
afs_int32 OptSalvageRemote;
afs_int32 OptSalvageArchival;
afs_int32 OptIgnoreCheck;
afs_int32 OptForceOnLine;
afs_int32 OptUseRootDirACL;
afs_int32 OptTraceBadLinkCounts;
afs_int32 OptDontAskFS;
afs_int32 OptLogLevel;
afs_int32 OptRxDebug;
afs_uint32 OptResidencies;
} mrafsParm;
static int DoSalvage(aconn, aparm1, aparm2, aoutName, showlog, parallel, atmpDir, orphans)
struct rx_connection *aconn;
char *aoutName;
char *aparm1;
char *aparm2;
afs_int32 showlog;
char *parallel;
char *atmpDir;
char *orphans;
{
register afs_int32 code;
char *parms[6];
char buffer;
char tbuffer[BOZO_BSSIZE];
struct bozo_status istatus;
struct rx_call *tcall;
char *tp;
FILE *outFile;
int closeIt = 0;
char partName[20]; /* canonical name for partition */
char pbuffer[PARMBUFFERSSIZE];
afs_int32 partNumber;
char *notifier = NONOTIFIER;
/* if a partition was specified, canonicalize the name, since
the salvager has a stupid partition ID parser */
if (aparm1) {
partNumber = volutil_GetPartitionID(aparm1);
if (partNumber < 0) {
char buffer[256];
sprintf(buffer, "AFS::BOS: could not parse partition ID '%s'\n", aparm1);
BSETCODE(EINVAL, buffer);
return EINVAL;
}
tp = (char *) volutil_PartitionName(partNumber);
if (!tp) {
char buffer[256];
sprintf(buffer, "AFS::BOS: internal error parsing partition ID '%s'\n",
aparm1);
BSETCODE(EINVAL, buffer);
return EINVAL;
}
strcpy(partName, tp);
}
else
partName[0] = 0;
/* open the file name */
if (aoutName) {
outFile = fopen(aoutName, "w");
if (!outFile) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't open specified SalvageLog file '%s'\n",
aoutName);
BSETCODE(ENOENT, buffer);
return ENOENT;
}
closeIt = 1; /* close this file later */
}
else {
outFile = stdout;
closeIt = 0; /* don't close this file later */
}
for (code = 2; code < 6; code++)
parms[code] = "";
if (!aparm2)
aparm2 = "";
/* MUST pass canonical (wire-format) salvager path to bosserver */
strncpy(tbuffer, AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH, BOZO_BSSIZE);
if (*aparm2 != 0) {
if ((strlen(tbuffer) + 1 + strlen(partName) + 1 + strlen(aparm2) + 1) >
BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " ");
strcat(tbuffer, partName);
strcat(tbuffer, " ");
strcat(tbuffer, aparm2);
}
else {
if ((strlen(tbuffer) + 4 + strlen(partName) + 1) > BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " -f ");
strcat(tbuffer, partName);
}
/* add the parallel option if given */
if (parallel != (char *) 0) {
if ((strlen(tbuffer) + 11 + strlen(parallel) + 1) > BOZO_BSSIZE) {
char buffer[256];
if (mrafsParm.Optnowrite)
strcat(tbuffer, " -nowrite");
if (mrafsParm.Optforce)
strcat(tbuffer, " -force");
if (mrafsParm.Optoktozap)
strcat(tbuffer, " -oktozap");
if (mrafsParm.Optrootfiles)
strcat(tbuffer, " -rootfiles");
if (mrafsParm.Optsalvagedirs)
strcat(tbuffer, " -salvagedirs");
if (mrafsParm.Optblockreads)
strcat(tbuffer, " -blockreads");
if (mrafsParm.OptListResidencies)
strcat(tbuffer, " -ListResidencies");
if (mrafsParm.OptSalvageRemote)
strcat(tbuffer, " -SalvageRemote");
if (mrafsParm.OptSalvageArchival)
strcat(tbuffer, " -SalvageArchival");
if (mrafsParm.OptIgnoreCheck)
strcat(tbuffer, " -IgnoreCheck");
if (mrafsParm.OptForceOnLine)
strcat(tbuffer, " -ForceOnLine");
if (mrafsParm.OptUseRootDirACL)
strcat(tbuffer, " -UseRootDirACL");
if (mrafsParm.OptTraceBadLinkCounts)
strcat(tbuffer, " -TraceBadLinkCounts");
if (mrafsParm.OptDontAskFS)
strcat(tbuffer, " -DontAskFS");
if (mrafsParm.OptLogLevel) {
sprintf(pbuffer, " -LogLevel %d", mrafsParm.OptLogLevel);
strcat(tbuffer, pbuffer);
}
if (mrafsParm.OptRxDebug)
strcat(tbuffer, " -rxdebug");
if (mrafsParm.OptResidencies) {
sprintf(pbuffer, " -Residencies %u", mrafsParm.OptResidencies);
strcat(tbuffer, pbuffer);
}
parms[0] = tbuffer;
parms[1] = "now"; /* when to do it */
code = BOZO_CreateBnode(aconn, "cron", "salvage-tmp", parms[0], parms[1],
parms[2], parms[3], parms[4], notifier);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to start 'salvager' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
/* now wait for bnode to disappear */
while (1) {
#ifdef AFS_PTHREAD_ENV
sleep(5);
#else
IOMGR_Sleep(5);
#endif /* AFS_PTHREAD_ENV*/
tp = tbuffer;
code = BOZO_GetInstanceInfo(aconn, "salvage-tmp", &tp, &istatus);
if (code)
break;
/* fprintf(stderr, "AFS::BOS: waiting for salvage to complete.\n"); */
}
if (code != BZNOENT) {
char buffer[256];
sprintf(buffer, "AFS::BOS: salvage failed (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = 0;
/* now print the log file to the output file */
/* fprintf(stderr, "AFS::BOS: salvage completed\n"); */
if (aoutName || showlog) {
fprintf(outFile, "SalvageLog:\n");
tcall = rx_NewCall(aconn);
/* MUST pass canonical (wire-format) salvager log path to bosserver */
code = StartBOZO_GetLog(tcall, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH);
if (code) {
rx_EndCall(tcall, code);
goto done;
}
/* copy data */
while (1) {
code = rx_Read(tcall, &buffer, 1);
if (code != 1)
break;
putc(buffer, outFile);
if (buffer == 0)
break; /* the end delimeter */
}
code = rx_EndCall(tcall, 0);
/* fall through into cleanup code */
}
done:
if (closeIt && outFile)
fclose(outFile);
return code;
}
/* end of helper functions for BOS class */
/* helper functions for FS class: */
static int32 isafs(path, follow)
char *path;
int32 follow;
{
struct ViceIoctl vi;
register int32 code;
char space[MAXSIZE];
vi.in_size = 0;
vi.out_size = MAXSIZE;
vi.out = space;
code = pioctl(path, VIOC_FILE_CELL_NAME, &vi, follow);
if (code) {
if ((errno == EINVAL) || (errno == ENOENT))
return 0;
if (errno == ENOSYS)
return 0;
}
return 1;
}
static char *format_rights(rights)
int32 rights;
{
static char buff[32];
char *p;
p = buff;
if (rights & PRSFS_READ) {
*p++ = 'r';
}
if (rights & PRSFS_LOOKUP) {
*p++ = 'l';
}
if (rights & PRSFS_INSERT) {
*p++ = 'i';
}
if (rights & PRSFS_DELETE) {
*p++ = 'd';
}
if (rights & PRSFS_WRITE) {
*p++ = 'w';
}
if (rights & PRSFS_LOCK) {
*p++ = 'k';
}
if (rights & PRSFS_ADMINISTER) {
*p++ = 'a';
}
if (rights & PRSFS_USR0) {
*p++ = 'A';
}
if (rights & PRSFS_USR1) {
*p++ = 'B';
}
if (rights & PRSFS_USR2) {
*p++ = 'C';
}
if (rights & PRSFS_USR3) {
*p++ = 'D';
}
if (rights & PRSFS_USR4) {
*p++ = 'E';
}
if (rights & PRSFS_USR5) {
*p++ = 'F';
}
if (rights & PRSFS_USR6) {
*p++ = 'G';
}
if (rights & PRSFS_USR7) {
*p++ = 'H';
}
*p = 0;
if (ht == NULL)
h = (char *) inet_ntoa(hosts[i]);
else
h = ht->h_name;
}
else {
h = (char *) inet_ntoa(hosts[i]);
}
XPUSHs(sv_2mortal(newSVpv(h, strlen(h))));
}
}
}
void
fs__get_server_version(port,hostName="localhost",verbose=0)
short port
char *hostName
int32 verbose
CODE:
{
#if defined(AFS_3_4)
not_here("AFS::Utils::get_server_version");
#else
struct sockaddr_in taddr;
struct in_addr hostAddr;
struct hostent *th;
int32 host;
short port_num = htons(port);
int32 length = 64;
int32 code;
char version[64];
int s;
/* lookup host */
if (hostName) {
th = (struct hostent *) hostutil_GetHostByName(hostName);
if (!th) {
warn("rxdebug: host %s not found in host table\n", hostName);
SETCODE(EFAULT);
XSRETURN_UNDEF;
}
/* bcopy(th->h_addr, &host, sizeof(int32)); */
Copy(th->h_addr, &host, th->h_length, char);
}
else
host = htonl(0x7f000001); /* IP localhost */
hostAddr.s_addr = host;
if (verbose)
printf("Trying %s (port %d):\n", inet_ntoa(hostAddr), ntohs(port_num));
s = socket(AF_INET, SOCK_DGRAM, 0);
taddr.sin_family = AF_INET;
taddr.sin_port = 0;
taddr.sin_addr.s_addr = 0;
code = bind(s, (struct sockaddr *) &taddr, sizeof(struct sockaddr_in));
SETCODE(code);
if (code) {
perror("bind");
XSRETURN_UNDEF;
}
code = rx_GetServerVersion(s, host, port_num, length, version);
ST(0) = sv_newmortal();
if (code < 0) {
SETCODE(code);
}
else {
sv_setpv(ST(0), version);
}
#endif
}
void
fs_get_syslib_version()
CODE:
{
extern char *AFSVersion;
ST(0) = sv_newmortal();
sv_setpv(ST(0), AFSVersion);
}
void
fs_XSVERSION()
CODE:
{
ST(0) = sv_newmortal();
sv_setpv(ST(0), xs_version);
}
void
fs_sysname(newname=0)
char * newname
CODE:
{
struct ViceIoctl vi;
int32 code, set;
char space[MAXSIZE];
set = (newname && *newname);
vi.in = space;
bcopy(&set, space, sizeof(set));
vi.in_size = sizeof(set);
if (set) {
strcpy(space + sizeof(set), newname);
vi.in_size += strlen(newname) + 1;
}
vi.out_size = MAXSIZE;
vi.out = (caddr_t) space;
code = pioctl(NULL, VIOC_AFS_SYSNAME, &vi, 0);
SETCODE(code);
ST(0) = sv_newmortal();
if (code == 0) {
sv_setpv(ST(0), space + sizeof(set));
}
}
vi.in_size = sizeof(size);;
vi.in = (char *) &size;
vi.out_size = 0;
vi.out = 0;
code = pioctl(NULL, VIOCSETCACHESIZE, &vi, 0);
SETCODE(code);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
fs_unlog()
CODE:
{
struct ViceIoctl vi;
int32 code;
vi.in_size = 0;
vi.out_size = 0;
code = pioctl(NULL, VIOCUNLOG, &vi, 0);
SETCODE(code);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
fs_getfid(path,follow=1)
char * path
int32 follow
PPCODE:
{
struct ViceIoctl vi;
int32 code;
struct VenusFid vf;
vi.in_size = 0;
vi.out_size = sizeof(vf);
vi.out = (char *) &vf;
code = pioctl(path, VIOCGETFID, &vi, follow);
SETCODE(code);
if (code == 0) {
EXTEND(sp, 4);
PUSHs(sv_2mortal(newSViv(vf.Cell)));
PUSHs(sv_2mortal(newSViv(vf.Fid.Volume)));
PUSHs(sv_2mortal(newSViv(vf.Fid.Vnode)));
PUSHs(sv_2mortal(newSViv(vf.Fid.Unique)));
}
}
int32
fs_isafs(path,follow=1)
char * path
int32 follow
CODE:
{
int32 code;
RETVAL = isafs(path, follow);
if (!RETVAL)
code = errno;
else
code = 0;
SETCODE(code);
}
OUTPUT:
RETVAL
int32
fs_cm_access(path,perm="read",follow=1)
char * path
char * perm
int32 follow
CODE:
{
struct ViceIoctl vi;
int32 code;
int32 rights;
code = canonical_parse_rights(perm, &rights);
if (code == 0) {
code = vi.in_size = sizeof(rights);
vi.in = (char *) &rights;
vi.out_size = 0;
vi.out = 0;
code = pioctl(path, VIOCACCESS, &vi, follow);
}
SETCODE(code);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
fs_ascii2rights(perm)
char * perm
CODE:
{
int32 code, rights = -1;
code = canonical_parse_rights(perm, &rights);
SETCODE(code);
if (code != 0)
rights = -1;
RETVAL = rights;
}
OUTPUT:
RETVAL
void
fs_rights2ascii(perm)
int32 perm
CODE:
{
char *p;
p = format_rights(perm);
SETCODE(0);
ST(0) = sv_newmortal();
int32
vos__DESTROY(self)
AFS::VOS self
PREINIT:
int32 code;
CODE:
{
code = ubik_ClientDestroy((struct ubik_client *) self);
/* printf("DEBUG-23 %d \n", code); */
SETCODE(code);
/* printf("DEBUG-24 \n"); */
RETVAL = (code == 0);
/* printf("DEBUG-25 \n"); */
}
OUTPUT:
RETVAL
void
vos_status(cstruct, aserver)
AFS::VOS cstruct
char *aserver
PREINIT:
afs_int32 server, code;
transDebugInfo *pntr;
afs_int32 count;
char buffer[256];
CODE:
{
server = GetServer(aserver);
if (!server) {
sprintf(buffer, "AFS::VOS: host '%s' not found in host table\n", aserver);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
code = UV_VolserStatus(server, &pntr, &count);
if (code) {
PrintDiagnostics("status", code);
SETCODE(1);
XSRETURN_UNDEF;
}
ST(0) = sv_newmortal();
SETCODE(0);
if (count == 0) {
sprintf(buffer, "No active transactions on %s\n", aserver);
sv_setpv(ST(0), buffer);
}
else {
sprintf(buffer, "Total transactions: %d\n", count);
sv_setpv(ST(0), buffer);
}
XSRETURN(1);
}
int32
vos_release(cstruct, name, force=Nullsv)
AFS::VOS cstruct
char *name
SV * force
PREINIT:
struct nvldbentry entry;
afs_int32 avolid, aserver, apart, vtype, code, err;
int iforce;
CODE:
{
if (!force) {
force = newSViv(0);
}
if (!SvIOKp(force)) {
char buffer[256];
sprintf(buffer, "Flag \"force\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
XSRETURN_UNDEF;
}
iforce = SvIV(force);
RETVAL = 0;
avolid = vsu_GetVolumeID(name, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume '%s'\n", name);
VSETCODE(err ? err : ENOENT, buffer);
goto done;
}
code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);
if (code) {
SETCODE(code);
goto done;
}
if (vtype != RWVOL) {
char buffer[256];
sprintf(buffer, "%s not a RW volume\n", name);
VSETCODE(ENOENT, buffer);
goto done;
}
if (!ISNAMEVALID(entry.name)) {
char buffer[256];
sprintf(buffer, "Volume name %s is too long, rename before releasing\n", entry.name);
VSETCODE(E2BIG, buffer);
goto done;
}
code = UV_ReleaseVolume(avolid, aserver, apart, iforce);
if (code) {
PrintDiagnostics("release", code);
SETCODE(code);
goto done;
}
#fprintf(STDOUT, "Released volume %s successfully\n", name);
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vos_create(cstruct, server, partition, name, maxquota=Nullsv, vid=Nullsv, rovid=Nullsv)
AFS::VOS cstruct
char *server
char *partition
char *name
SV * maxquota
SV * vid
SV * rovid
PREINIT:
int32 pnum;
int32 code;
struct nvldbentry entry;
int32 vcode;
int32 quota = 5000;
afs_int32 tserver;
#ifdef OpenAFS_1_4_12
afs_uint32 volid = 0, rovolid = 0, bkvolid = 0;
afs_uint32 *arovolid = NULL;
#else
afs_int32 volid = 0;
#endif
CODE:
{
if (!maxquota)
maxquota = newSViv(0);
if (!vid)
vid = newSViv(0);
if (!rovid)
rovid = newSViv(0);
RETVAL = 0;
/* printf("vos-create DEBUG-1 server %s part %s vol %s maxq %d vid %d rovid %d \n", server, partition, name, SvIV(maxquota), SvIV(vid), SvIV(rovid)); */
tserver = GetServer(server);
if (!tserver) {
char buffer[256];
sprintf(buffer, "AFS::VOS: host '%s' not found in host table\n", server);
VSETCODE(ENOENT, buffer);
goto done;
}
pnum = volutil_GetPartitionID(partition);
if (pnum < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", partition);
VSETCODE(ENOENT, buffer);
goto done;
}
if (!IsPartValid(pnum, tserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
partition);
VSETCODE(code ? code : ENOENT, buffer);
goto done;
}
if (!ISNAMEVALID(name)) {
char buffer[256];
sprintf(buffer,
"AFS::VOS: the name of the root volume %s exceeds the size limit of %d\n",
name, VOLSER_OLDMAXVOLNAME - 10);
VSETCODE(E2BIG, buffer);
goto done;
}
if (!VolNameOK(name)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not end in .readonly or .backup\n",
name);
VSETCODE(EINVAL, buffer);
goto done;
}
if (IsNumeric(name)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not be a number\n", name);
VSETCODE(EINVAL, buffer);
goto done;
}
vcode = VLDB_GetEntryByName(name, &entry);
if (!vcode) {
char buffer[256];
sprintf(buffer, "Volume %s already exists\n", name);
#PrintDiagnostics("create", code);
VSETCODE(EEXIST, buffer);
goto done;
}
/* printf("vos-create DEBUG-2 server %d part %d vol %s maxq %d vid %d rovid %d \n", tserver, pnum, name, SvIV(maxquota), SvIV(vid), SvIV(rovid)); */
if ((maxquota) && (!SvIOKp(maxquota))) {
char buffer[256];
sprintf(buffer, "Initial quota should be numeric.\n");
VSETCODE(EINVAL, buffer);
goto done;
}
quota = SvIV(maxquota);
/* printf("vos-create DEBUG-3 quota %d \n", quota); */
#ifdef OpenAFS_1_4_12
if ((vid) && (!SvIOKp(vid))) {
/* printf("vos-create DEBUG-4 vid %d \n", SvIV(vid)); */
char buffer[256];
sprintf(buffer, "Given volume ID should be numeric.\n");
VSETCODE(EINVAL, buffer);
goto done;
}
/* printf("vos-create DEBUG-5 vid %d \n", SvIV(vid)); */
volid = SvIV(vid);
/* printf("vos-create DEBUG-6 volid %d \n", volid); */
if ((rovid) && (!SvIOKp(rovid))) {
/* printf("vos-create DEBUG-7 rovid %d \n", SvIV(rovid)); */
char buffer[256];
sprintf(buffer, "Given RO volume ID should be numeric.\n");
VSETCODE(EINVAL, buffer);
goto done;
}
/* printf("vos-create DEBUG-8 rovid %d \n", SvIV(rovid)); */
arovolid = &rovolid;
rovolid = SvIV(rovid);
/* printf("vos-create DEBUG-9 rovolid %d \n", rovolid); */
if (rovolid == 0) {
arovolid = NULL;
}
code = UV_CreateVolume3(tserver, pnum, name, quota, 0, 0, 0, 0, &volid, arovolid, &bkvolid);
#else
code = UV_CreateVolume2(tserver, pnum, name, quota, 0, 0, 0, 0, &volid);
#endif
if (code) {
#PrintDiagnostics("create", code);
SETCODE(code);
goto done;
}
SETCODE(0);
RETVAL = (int32)volid;
done:
;
}
OUTPUT:
RETVAL
int32
vos_backup(cstruct, name)
AFS::VOS cstruct
char *name
PREINIT:
int32 avolid, aserver, apart, vtype, code, err;
int32 buvolid, buserver, bupart, butype;
struct nvldbentry entry;
struct nvldbentry buentry;
CODE:
{
RETVAL = 0;
avolid = vsu_GetVolumeID(name, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume ID or name '%s'\n", name);
VSETCODE(err ? err : ENOENT, buffer);
goto done;
}
code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);
if (code) {
SETCODE(code);
goto done;
}
/* verify this is a readwrite volume */
if (vtype != RWVOL) {
char buffer[256];
sprintf(buffer, "%s not RW volume\n", name);
VSETCODE(-1, buffer);
goto done;
}
/* is there a backup volume already? */
if (entry.flags & BACK_EXISTS) {
/* yep, where is it? */
buvolid = entry.volumeId[BACKVOL];
code = GetVolumeInfo(buvolid, &buserver, &bupart, &butype, &buentry);
if (code) {
SETCODE(code);
goto done;
}
/* is it local? */
code = VLDB_IsSameAddrs(buserver, aserver, &err);
if (err) {
char buffer[256];
sprintf(buffer,
"Failed to get info about server's %d address(es) from vlserver; aborting call!\n",
buserver);
VSETCODE(err, buffer);
goto done;
}
if (!code) {
char buffer[256];
sprintf(buffer, "FATAL ERROR: backup volume %u exists on server %u\n",
buvolid, buserver);
VSETCODE(-1, buffer);
goto done;
}
}
/* nope, carry on */
code = UV_BackupVolume(aserver, apart, avolid);
if (code) {
PrintDiagnostics("backup", code);
SETCODE(0);
goto done;
}
#fprintf(STDOUT, "Created backup volume for %s \n", name);
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vos_remove(cstruct, name, servername=NULL, parti=NULL)
AFS::VOS cstruct
char *name
char *servername
char *parti
PREINIT:
afs_int32 err, code = 0;
afs_int32 server = 0, partition = -1, volid;
afs_int32 idx, j;
CODE:
{
RETVAL = 0;
if (servername && strlen(servername) != 0) {
server = GetServer(servername);
if (!server) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", servername);
VSETCODE(ENOENT, buffer);
goto done;
}
}
if (parti && strlen(parti) != 0) {
partition = volutil_GetPartitionID(parti);
if (partition < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", parti);
VSETCODE(EINVAL, buffer);
goto done;
}
/* Check for validity of the partition */
if (!IsPartValid(partition, server, &code)) {
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
parti);
VSETCODE(ENOENT, buffer);
goto done;
}
}
volid = vsu_GetVolumeID(name, cstruct, &err);
if (volid == 0) {
char buffer[256];
sprintf(buffer, "Can't find volume name '%s' in VLDB\n", name);
if (err)
set_errbuff(buffer, err);
VSETCODE(ENOENT, buffer);
goto done;
}
/* If the server or partition option are not complete, try to fill
* them in from the VLDB entry.
*/
if ((partition == -1) || !server) {
struct nvldbentry entry;
code = VLDB_GetEntryByID(volid, -1, &entry);
if (code) {
char buffer[256];
sprintf(buffer, "Could not fetch the entry for volume %u from VLDB\n", volid);
VSETCODE(code, buffer);
goto done;
}
if (((volid == entry.volumeId[RWVOL]) && (entry.flags & RW_EXISTS)) ||
((volid == entry.volumeId[BACKVOL]) && (entry.flags & BACK_EXISTS))) {
idx = Lp_GetRwIndex(&entry);
if ((idx == -1) ||
(server && (server != entry.serverNumber[idx])) ||
((partition != -1) && (partition != entry.serverPartition[idx]))) {
char buffer[256];
sprintf(buffer, "AFS::VOS: Volume '%s' no match\n", name);
VSETCODE(ENOENT, buffer);
goto done;
}
}
else if ((volid == entry.volumeId[ROVOL]) && (entry.flags & RO_EXISTS)) {
for (idx = -1, j = 0; j < entry.nServers; j++) {
if (entry.serverFlags[j] != ITSROVOL)
continue;
if (((server == 0) || (server == entry.serverNumber[j])) &&
((partition == -1) || (partition == entry.serverPartition[j]))) {
if (idx != -1) {
char buffer[256];
sprintf(buffer, "AFS::VOS: Volume '%s' matches more than one RO\n",
name);
VSETCODE(ENOENT, buffer);
goto done;
}
idx = j;
}
}
if (idx == -1) {
char buffer[256];
sprintf(buffer, "AFS::VOS: Volume '%s' no match\n", name);
VSETCODE(ENOENT, buffer);
goto done;
}
}
else {
char buffer[256];
sprintf(buffer, "AFS::VOS: Volume '%s' no match\n", name);
VSETCODE(ENOENT, buffer);
goto done;
}
newname);
VSETCODE(-1, buffer);
goto done;
}
if (!VolNameOK(oldname)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not end in .readonly or .backup\n",
oldname);
VSETCODE(-1, buffer);
goto done;
}
if (!ISNAMEVALID(newname)) {
char buffer[256];
sprintf(buffer, "AFS::VOS: the new volume name %s exceeds the size limit of %d\n",
newname, VOLSER_OLDMAXVOLNAME - 10);
VSETCODE(-1, buffer);
goto done;
}
if (!VolNameOK(newname)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not end in .readonly or .backup\n",
newname);
VSETCODE(-1, buffer);
goto done;
}
if (IsNumeric(newname)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not be a number\n", newname);
VSETCODE(-1, buffer);
goto done;
}
MapHostToNetwork(&entry);
code = UV_RenameVolume(&entry, oldname, newname);
if (code) {
PrintDiagnostics("rename", code);
SETCODE(code);
goto done;
}
#fprintf(STDOUT, "Renamed volume %s to %s\n", oldname, newname);
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vos__setfields(cstruct, name, mquota=Nullsv, clearuse=Nullsv)
AFS::VOS cstruct
char *name
SV * mquota
SV * clearuse
PREINIT:
#ifdef OpenAFS
struct nvldbentry entry;
volintInfo info;
int32 volid;
int32 clear, code, err;
int32 aserver, apart;
int previdx = -1;
#endif
CODE:
{
#ifdef OpenAFS
if (!mquota)
mquota = newSViv(-1);
if (!clearuse)
clearuse = newSViv(0);
if ((!SvIOKp(mquota))) { /* -max <quota> */
char buffer[256];
sprintf(buffer, "invalid quota value\n");
VSETCODE(EINVAL, buffer);
goto done;
}
if ((!SvIOKp(clearuse))) { /* -clearuse */
char buffer[256];
sprintf(buffer, "flag \"clearuse\" is not an integer\n");
VSETCODE(EINVAL, buffer);
goto done;
}
/* printf("vos-setfields DEBUG-1 name %s mquota %d clearuse %d \n", name, (int)SvIV(mquota), (int)SvIV(clearuse)); */
RETVAL = 0;
volid = vsu_GetVolumeID(name, cstruct, &err); /* -id */
if (volid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "Unknown volume ID or name '%s'\n", name);
VSETCODE(err ? err : -1, buffer);
goto done;
}
code = VLDB_GetEntryByID(volid, RWVOL, &entry);
if (code) {
char buffer[256];
sprintf(buffer, "Could not fetch the entry for volume number %u from VLDB \n", volid);
VSETCODE(code, buffer);
goto done;
}
MapHostToNetwork(&entry);
GetServerAndPart(&entry, RWVOL, &aserver, &apart, &previdx);
if (previdx == -1) {
char buffer[256];
sprintf(buffer, "Volume %s does not exist in VLDB\n\n", name);
VSETCODE(ENOENT, buffer);
goto done;
}
Zero(&info, 1, volintInfo);
info.volid = volid;
info.type = RWVOL;
info.creationDate = -1;
info.updateDate = -1;
info.dayUse = -1;
info.maxquota = -1;
info.flags = -1;
info.spare0 = -1;
info.spare1 = -1;
info.spare2 = -1;
info.spare3 = -1;
info.maxquota = SvIV(mquota);
clear = SvIV(clearuse);
if (clear)
info.dayUse = 0;
code = UV_SetVolumeInfo(aserver, apart, volid, &info);
if (code) {
char buffer[256];
sprintf(buffer, "Could not update volume info fields for volume number %u\n", volid);
VSETCODE(code, buffer);
}
else
SETCODE(code);
RETVAL = 1;
done:
;
#else
not_here("AFS::VOS::setfields");
#endif
}
OUTPUT:
RETVAL
int32
vos_restore(cstruct,server,partition,name,file=NULL,id=NULL,inter=Nullsv,overwrite=NULL,offline=Nullsv,readonly=Nullsv)
AFS::VOS cstruct
char *server
char *partition
char *name
char *file
char *id
SV * inter
char *overwrite
SV * offline
SV * readonly
PREINIT:
afs_int32 avolid, aparentid, aserver, apart, code, vcode, err;
afs_int32 aoverwrite = AFS_ASK;
int restoreflags, voltype = RWVOL, ireadonly = 0, ioffline = 0;
char afilename[NameLen], avolname[VOLSER_MAXVOLNAME +1];
char volname[VOLSER_MAXVOLNAME +1];
struct nvldbentry entry;
CODE:
{
aparentid = 0;
if (!inter) {
inter = newSViv(0);
}
if (!offline) {
offline = newSViv(0);
}
if (!readonly) {
readonly = newSViv(0);
}
if ((!SvIOKp(inter))) {
char buffer[256];
sprintf(buffer, "Flag \"inter\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
aoverwrite = AFS_ASK;
if ((!SvIOKp(offline))) {
char buffer[256];
sprintf(buffer, "Flag \"offline\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
ioffline = SvIV(offline);
if ((!SvIOKp(readonly))) {
char buffer[256];
sprintf(buffer, "Flag \"readonly\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
ireadonly = SvIV(readonly);
if (id && strlen(id) != 0) {
avolid = vsu_GetVolumeID(id, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
RETVAL = 0;
goto done;
}
}
else
avolid = 0;
if (overwrite && strlen(overwrite) != 0) {
if ((strcmp(overwrite, "a") == 0) || (strcmp(overwrite, "abort") == 0)) {
aoverwrite = AFS_ABORT;
}
else if ((strcmp(overwrite, "f") == 0) || (strcmp(overwrite, "full") == 0)) {
aoverwrite = AFS_FULL;
}
else if ((strcmp(overwrite, "i") == 0) ||
(strcmp(overwrite, "inc") == 0) ||
(strcmp(overwrite, "increment") == 0) ||
(strcmp(overwrite, "incremental") == 0)) {
aoverwrite = AFS_INC;
}
else {
char buffer[256];
sprintf(buffer, "AFS::VOS: %s is not a valid OVERWRITE argument\n",
overwrite);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
}
if ((ireadonly))
voltype = ROVOL;
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", partition);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
partition);
VSETCODE(code ? code : -1, buffer);
RETVAL = 0;
goto done;
}
strcpy(avolname, name);
if (!ISNAMEVALID(avolname)) {
char buffer[256];
sprintf(buffer, "AFS::VOS: the name of the volume %s exceeds the size limit\n",
avolname);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
if (!VolNameOK(avolname)) {
char buffer[256];
sprintf(buffer, "Illegal volume name %s, should not end in .readonly or .backup\n",
avolname);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
if (file && strlen(file) != 0) {
strcpy(afilename, file);
if (!FileExists(afilename)) {
char buffer[256];
sprintf(buffer, "Can't access file %s\n", afilename);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
}
else {
strcpy(afilename, "");
}
/* Check if volume exists or not */
vsu_ExtractName(volname, avolname);
vcode = VLDB_GetEntryByName(volname, &entry);
if (vcode) { /* no volume - do a full restore */
restoreflags = RV_FULLRST;
if ((aoverwrite == AFS_INC) || (aoverwrite == AFS_ABORT)) {
char buffer[256];
sprintf(buffer, "Volume does not exist; Will perform a full restore\n");
VSETCODE(vcode, buffer);
}
}
else if ((!ireadonly && Lp_GetRwIndex(&entry) == -1) /* RW volume does not exist - do a full */
||(ireadonly && !Lp_ROMatch(0, 0, &entry))) { /* RO volume does not exist - do a full */
restoreflags = RV_FULLRST;
if ((aoverwrite == AFS_INC) || (aoverwrite == AFS_ABORT))
fprintf(stderr, "%s Volume does not exist; Will perform a full restore\n",
ireadonly ? "RO" : "RW");
if (avolid == 0) {
avolid = entry.volumeId[voltype];
}
else if (entry.volumeId[voltype] != 0 && entry.volumeId[voltype] != avolid) {
avolid = entry.volumeId[voltype];
}
aparentid = entry.volumeId[RWVOL];
}
else { /* volume exists - do we do a full incremental or abort */
int Oserver, Opart, Otype, vol_elsewhere = 0;
struct nvldbentry Oentry;
int c, dc;
if (avolid == 0) {
avolid = entry.volumeId[voltype];
}
else if (entry.volumeId[voltype] != 0 && entry.volumeId[voltype] != avolid) {
avolid = entry.volumeId[voltype];
}
aparentid = entry.volumeId[RWVOL];
/* A file name was specified - check if volume is on another partition */
vcode = GetVolumeInfo(avolid, &Oserver, &Opart, &Otype, &Oentry);
if (vcode) {
SETCODE(0);
RETVAL = 0;
goto done;
}
vcode = VLDB_IsSameAddrs(Oserver, aserver, &err);
if (err) {
char buffer[256];
sprintf(buffer,
"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",
Oserver, err);
VSETCODE(err, buffer);
RETVAL = 0;
goto done;
}
if (!vcode || (Opart != apart))
vol_elsewhere = 1;
if (aoverwrite == AFS_ASK) {
if (strcmp(afilename, "") == 0) { /* The file is from standard in */
char buffer[256];
sprintf(buffer,
"Volume exists and no OVERWRITE argument specified; Aborting restore command\n");
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
/* Ask what to do */
if (vol_elsewhere) {
char buffer[256];
sprintf(buffer,
"The volume %s %u already exists on a different server/part\n",
volname, entry.volumeId[voltype]);
VSETCODE(-1, buffer);
fprintf(stderr, "Do you want to do a full restore or abort? [fa](a): ");
}
else {
char buffer[256];
sprintf(buffer, "The volume %s %u already exists in the VLDB\n",
volname, entry.volumeId[voltype]);
VSETCODE(-1, buffer);
fprintf(stderr,
"Do you want to do a full/incremental restore or abort? [fia](a): ");
}
dc = c = getchar();
while (!(dc == EOF || dc == '\n'))
dc = getchar(); /* goto end of line */
if ((c == 'f') || (c == 'F'))
aoverwrite = AFS_FULL;
else if ((c == 'i') || (c == 'I'))
aoverwrite = AFS_INC;
else
aoverwrite = AFS_ABORT;
}
if (aoverwrite == AFS_ABORT) {
char buffer[256];
sprintf(buffer, "Volume exists; Aborting restore command\n");
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
else if (aoverwrite == AFS_FULL) {
restoreflags = RV_FULLRST;
fprintf(stderr, "Volume exists; Will delete and perform full restore\n");
}
else if (aoverwrite == AFS_INC) {
restoreflags = 0;
if (vol_elsewhere) {
char buffer[256];
sprintf(buffer,
"%s volume %u already exists on a different server/part; not allowed\n",
ireadonly ? "RO" : "RW", avolid);
VSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
}
}
if ((ioffline))
restoreflags |= RV_OFFLINE;
if (ireadonly)
restoreflags |= RV_RDONLY;
/* restoreflags |= RV_CRNEW; */
/* restoreflags |= RV_LUDUMP; */
#ifdef OpenAFS_1_4_05
code = UV_RestoreVolume2(aserver, apart, avolid, aparentid, avolname,
restoreflags, WriteData, afilename);
#else
code = UV_RestoreVolume(aserver, apart, avolid, avolname,
restoreflags, WriteData, afilename);
#endif
if (code) {
PrintDiagnostics("restore", code);
SETCODE(code);
RETVAL = 0;
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vos_dump(cstruct, id, time=NULL, file=NULL, server=NULL, partition=NULL, clone=Nullsv, omit=Nullsv)
AFS::VOS cstruct
char *id
char *time
char *file
char *server
char *partition
SV * clone
SV * omit
PREINIT:
afs_int32 avolid, aserver, apart, voltype, fromdate=0, code=0, err, i;
char filename[NameLen];
struct nvldbentry entry;
afs_int32 omitdirs = 0;
CODE:
{
if (!clone)
clone = newSViv(0);
if (!omit)
omit = newSViv(0);
if ((!SvIOKp(omit))) {
char buffer[256];
sprintf(buffer, "Flag \"omit\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
omitdirs = SvIV(omit); /* -omit */
/* printf("vos_dump DEBUG-1 clone = %d omit = %d omitdirs = %d \n", clone, omit, omitdirs); */
RETVAL = 0;
rx_SetRxDeadTime(60 * 10);
for (i = 0; i < MAXSERVERS; i++) {
struct rx_connection *rxConn = ubik_GetRPCConn((struct ubik_client *) cstruct, i);
if (rxConn == 0)
break;
rx_SetConnDeadTime(rxConn, rx_connDeadTime);
if (rxConn->service)
rxConn->service->connDeadTime = rx_connDeadTime;
}
avolid = vsu_GetVolumeID(id, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume '%s'\n", id);
VSETCODE(err ? err : ENOENT, buffer);
goto done;
}
if ((server && (strlen(server) != 0)) || (partition && (strlen(partition) != 0))) {
if (!(server && (strlen(server) != 0)) || !(partition && (strlen(partition) != 0))) {
char buffer[256];
sprintf(buffer, "Must specify both SERVER and PARTITION arguments\n");
VSETCODE(-1, buffer);
goto done;
}
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "Invalid server name\n");
VSETCODE(-1, buffer);
goto done;
}
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "Invalid partition name\n");
VSETCODE(-1, buffer);
goto done;
}
}
else {
code = GetVolumeInfo(avolid, &aserver, &apart, &voltype, &entry);
if (code) {
SETCODE(code);
goto done;
}
}
if (time && strcmp(time, "0")) {
code = ktime_DateToInt32(time, &fromdate);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::VOS: failed to parse date '%s' (error=%d))\n", time, code);
VSETCODE(code, buffer);
goto done;
}
}
if (file && (strlen(file) != 0)) {
strcpy(filename, file);
}
else {
strcpy(filename, "");
}
#ifdef OpenAFS_1_4_05
int iclone = 0;
retry_dump:
/* printf("vos_dump DEBUG-2 clone = %d omitdirs = %d \n", clone, omitdirs); */
if ((!SvIOKp(clone))) {
char buffer[256];
sprintf(buffer, "Flag \"clone\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
iclone = SvIV(clone);
if (iclone) {
/* printf("vos_dump DEBUG-2-1 clone = %d omitdirs = %d \n", clone, omitdirs); */
code = UV_DumpClonedVolume(avolid, aserver, apart, fromdate,
DumpFunction, filename, omitdirs);
} else {
/* printf("vos_dump DEBUG-2-2 clone = %d omitdirs = %d \n", clone, omitdirs); */
code = UV_DumpVolume(avolid, aserver, apart, fromdate, DumpFunction,
filename, omitdirs);
}
/* printf("vos_dump DEBUG-3 code = %d \n", code); */
if ((code == RXGEN_OPCODE) && (omitdirs)) {
omitdirs = 0;
goto retry_dump;
}
#else
/* printf("vos_dump DEBUG-4 \n"); */
code = UV_DumpVolume(avolid, aserver, apart, fromdate, DumpFunction, filename);
/* printf("vos_dump DEBUG-5 code = %d \n", code); */
#endif
if (code) {
PrintDiagnostics("dump", code);
SETCODE(code);
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
void
vos_partinfo(cstruct, server, partname=NULL)
AFS::VOS cstruct
char *server
char *partname
PREINIT:
afs_int32 apart;
afs_int32 aserver, code;
char pname[10];
#ifdef OpenAFS_1_4_64
struct diskPartition64 partition;
#else
struct diskPartition partition;
#endif
struct partList dummyPartList;
int i, cnt;
HV *partlist = (HV*)sv_2mortal((SV*)newHV());
PPCODE:
{
apart = -1;
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
if (partname && (strlen(partname) != 0)) {
apart = volutil_GetPartitionID(partname);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", partname);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
dummyPartList.partId[0] = apart;
dummyPartList.partFlags[0] = PARTVALID;
cnt = 1;
}
if (apart != -1) {
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
partname);
VSETCODE(code ? code : -1, buffer);
XSRETURN_UNDEF;
}
}
else {
code = UV_ListPartitions(aserver, &dummyPartList, &cnt);
if (code) {
PrintDiagnostics("listpart", code);
SETCODE(code);
XSRETURN_UNDEF;
}
}
for (i = 0; i < cnt; i++) {
if (dummyPartList.partFlags[i] & PARTVALID) {
HV *part = (HV *) sv_2mortal((SV *) newHV());
MapPartIdIntoName(dummyPartList.partId[i], pname);
#ifdef OpenAFS_1_4_64
code = UV_PartitionInfo64(aserver, pname, &partition);
#else
code = UV_PartitionInfo(aserver, pname, &partition);
#endif
if (code) {
char buffer[256];
sprintf(buffer, "Could not get information on partition %s\n", pname);
VSETCODE(code, buffer);
XSRETURN_UNDEF;
}
safe_hv_store(part, "free", 4, newSViv(partition.free), 0);
safe_hv_store(part, "minFree", 7, newSViv(partition.minFree), 0);
safe_hv_store(partlist, pname, strlen(pname), newRV_inc((SV *) (part)), 0);
}
}
SETCODE(0);
ST(0) = sv_2mortal(newRV_inc((SV *) partlist));
XSRETURN(1);
}
void
vos_listvol(cstruct, server, partname=NULL, fast=Nullsv, extended=Nullsv)
AFS::VOS cstruct
char *server
char *partname
SV * fast
SV * extended
PREINIT:
afs_int32 apart = -1, aserver, code = 0;
volintInfo *pntr = (volintInfo *)0;
afs_int32 count;
int i;
volintXInfo *xInfoP = (volintXInfo *)0; /*Ptr to current/orig extended vol info*/
int wantExtendedInfo=0; /*Do we want extended vol info?*/
char pname[10];
struct partList dummyPartList;
if (!fast)
fast = newSViv(0);
if (!extended)
extended = newSViv(0);
if ((!SvIOKp(fast))) {
char buffer[256];
sprintf(buffer, "Flag \"fast\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
XSRETURN_UNDEF;
}
else
ifast = SvIV(fast); /* -fast */
if ((!SvIOKp(extended))) {
char buffer[256];
sprintf(buffer, "Flag \"extended\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
XSRETURN_UNDEF;
}
else
wantExtendedInfo = SvIV(extended); /* -extended */
if (ifast && wantExtendedInfo) {
char buffer[256];
sprintf(buffer, "AFS::VOS: FAST and EXTENDED flags are mutually exclusive\n");
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
/* printf ("vos_listvol DEBUG-1 pntr %p \n", pntr); */
/* printf ("vos_listvol DEBUG-1 xInfoP %p \n", xInfoP); */
if (ifast)
all = 0;
else
all = 1;
if (partname && (strlen(partname) != 0)) {
apart = volutil_GetPartitionID(partname);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", partname);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
dummyPartList.partId[0] = apart;
dummyPartList.partFlags[0] = PARTVALID;
cnt = 1;
}
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
if (apart != -1) {
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
partname);
VSETCODE(code ? code : -1, buffer);
XSRETURN_UNDEF;
}
}
else {
code = UV_ListPartitions(aserver, &dummyPartList, &cnt);
if (code) {
PrintDiagnostics("listvol", code);
SETCODE(-1);
XSRETURN_UNDEF;
}
}
for (i = 0; i < cnt; i++) {
if (dummyPartList.partFlags[i] & PARTVALID) {
/*HV *part = (HV*)sv_2mortal((SV*)newHV()); */
HV *part = newHV();
if (wantExtendedInfo)
code = UV_XListVolumes(aserver,
dummyPartList.partId[i], all, &xInfoP, &count);
else
code = UV_ListVolumes(aserver, dummyPartList.partId[i], all, &pntr, &count);
/* printf ("vos_listvol DEBUG-2 xInfoP %p %d \n", xInfoP, code); */
/* printf ("vos_listvol DEBUG-2 pntr %p %d \n", pntr, code); */
if (code) {
PrintDiagnostics("listvol", code);
if (pntr)
free(pntr);
SETCODE(-1);
XSRETURN_UNDEF;
}
MapPartIdIntoName(dummyPartList.partId[i], pname);
if (wantExtendedInfo) {
XDisplayVolumes(part,
aserver,
dummyPartList.partId[i],
xInfoP, count);
/* printf ("vos_listvol DEBUG-3 xInfoP %p \n", xInfoP); */
if (xInfoP)
free(xInfoP);
xInfoP = (volintXInfo *) 0;
}
else {
DisplayVolumes(part,
aserver,
dummyPartList.partId[i],
pntr, count, ifast);
/* printf ("vos_listvol DEBUG-4 pntr %p \n", pntr); */
if (pntr)
free(pntr);
pntr = (volintInfo *) 0;
}
safe_hv_store(vollist, pname, strlen(pname), newRV_inc((SV *) (part)), 0);
}
}
SETCODE(0);
ST(0) = sv_2mortal(newRV_inc((SV *) vollist));
XSRETURN(1);
}
int32
vos_move(cstruct, id, froms, fromp, tos, top)
AFS::VOS cstruct
char *id
char *froms
char *fromp
char *tos
char *top
PREINIT:
afs_int32 volid, fromserver, toserver, frompart, topart,code, err;
char fromPartName[10], toPartName[10];
#ifdef OpenAFS_1_4_64
struct diskPartition64 partition; /* for space check */
#else
struct diskPartition partition; /* for space check */
#endif
volintInfo *p;
CODE:
{
RETVAL = 0;
volid = vsu_GetVolumeID(id, cstruct, &err);
if (volid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume ID or name '%s'\n", id);
VSETCODE(err ? err : ENOENT, buffer);
goto done;
}
fromserver = GetServer(froms);
if (fromserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", froms);
VSETCODE(ENOENT, buffer);
goto done;
}
toserver = GetServer(tos);
if (toserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", tos);
VSETCODE(ENOENT, buffer);
goto done;
}
frompart = volutil_GetPartitionID(fromp);
if (frompart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", fromp);
VSETCODE(EINVAL, buffer);
goto done;
}
if (!IsPartValid(frompart, fromserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n", fromp);
VSETCODE(code ? code : ENOENT, buffer);
goto done;
}
topart = volutil_GetPartitionID(top);
if (topart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", top);
VSETCODE(EINVAL, buffer);
goto done;
}
if (!IsPartValid(topart, toserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n", top);
VSETCODE(code ? code : ENOENT, buffer);
goto done;
}
/*
check source partition for space to clone volume
*/
MapPartIdIntoName(topart, toPartName);
MapPartIdIntoName(frompart, fromPartName);
/*
check target partition for space to move volume
*/
#ifdef OpenAFS_1_4_64
code = UV_PartitionInfo64(toserver, toPartName, &partition);
#else
code = UV_PartitionInfo(toserver, toPartName, &partition);
#endif
if (code) {
char buffer[256];
sprintf(buffer, "AFS::VOS: cannot access partition %s\n", toPartName);
VSETCODE(code, buffer);
goto done;
}
p = (volintInfo *) 0;
code = UV_ListOneVolume(fromserver, frompart, volid, &p);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::VOS:cannot access volume %u\n", volid);
free(p);
VSETCODE(code, buffer);
goto done;
}
if (partition.free <= p->size) {
char buffer[256];
sprintf(buffer, "AFS::VOS: no space on target partition %s to move volume %u\n",
toPartName, volid);
VSETCODE(-1, buffer);
if (p)
free(p);
goto done;
}
if (p)
free(p);
/* successful move still not guaranteed but shoot for it */
code = UV_MoveVolume(volid, fromserver, frompart, toserver, topart);
if (code) {
PrintDiagnostics("move", code);
SETCODE(code);
goto done;
}
#SETCODE(1); ???
SETCODE(0);
RETVAL = volid;
done:
;
}
OUTPUT:
RETVAL
int32
vos_zap(cstruct, servername, parti, id, force=Nullsv, backup=Nullsv)
AFS::VOS cstruct
char *servername
char *parti
char *id
SV * force
SV * backup
PREINIT:
struct nvldbentry entry;
int32 volid, code, server, part, iforce=0, zapbackupid=0, backupid=0, err;
CODE:
{
if (!force)
force = newSViv(0);
if (!backup)
backup = newSViv(0);
if ((!SvIOKp(force))) {
char buffer[256];
sprintf(buffer, "Flag \"force\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
iforce = 1; /* -force */
if ((!SvIOKp(backup))) {
char buffer[256];
sprintf(buffer, "Flag \"backup\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
zapbackupid = 1; /* -backup */
RETVAL = 0;
volid = vsu_GetVolumeID(id, cstruct, &err);
if (volid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VOS: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
goto done;
}
part = volutil_GetPartitionID(parti);
if (part < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", parti);
VSETCODE(-1, buffer);
goto done;
}
server = GetServer(servername);
if (!server) {
char buffer[256];
sprintf(buffer, "AFS::VOS: host '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
goto done;
}
if (iforce) { /* -force */
code = UV_NukeVolume(server, part, volid);
if (code) {
PrintDiagnostics("zap", code);
SETCODE(code);
goto done;
}
SETCODE(0);
RETVAL = volid;
goto done;
}
if (!IsPartValid(part, server, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VOS: partition %s does not exist on the server\n",
servername);
VSETCODE(code ? code : -1, buffer);
goto done;
}
code = VLDB_GetEntryByID(volid, -1, &entry);
if (!code) {
if (volid == entry.volumeId[RWVOL])
backupid = entry.volumeId[BACKVOL];
#fprintf(stderr,
# "Warning: Entry for volume number %u exists in VLDB (but we're zapping it anyway!)\n",
# volid);
}
if (zapbackupid) {
volintInfo *pntr = (volintInfo *) 0;
if (!backupid) {
code = UV_ListOneVolume(server, part, volid, &pntr);
if (!code) {
if (volid == pntr->parentID)
backupid = pntr->backupID;
if (pntr)
free(pntr);
}
}
if (backupid) {
code = UV_VolumeZap(server, part, backupid);
if (code) {
PrintDiagnostics("zap", code);
SETCODE(code);
goto done;
}
fprintf(STDOUT, "Backup Volume %u deleted\n", backupid);
}
}
code = UV_VolumeZap(server, part, volid);
if (code) {
PrintDiagnostics("zap", code);
SETCODE(code);
goto done;
}
#fprintf(STDOUT, "Volume %u deleted\n", volid);
SETCODE(0);
RETVAL = volid;
done:
;
}
OUTPUT:
RETVAL
int32
vos_offline(cstruct, servername, parti, id, busy=Nullsv, sleep=Nullsv)
AFS::VOS cstruct
char* servername
char* parti
char *id
SV * busy
SV * sleep
PREINIT:
int32 server, partition, volid;
int32 code, err=0;
int32 ibusy=0, isleep=0, transflag, transdone;
CODE:
{
if (!busy)
busy = newSViv(0);
if (!sleep)
sleep = newSViv(0);
if ((!SvIOKp(busy))) {
char buffer[256];
sprintf(buffer, "Flag \"busy\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
ibusy = SvIV(busy); /* -busy */
if ((!SvIOKp(sleep))) {
char buffer[256];
sprintf(buffer, "Flag \"sleep\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
RETVAL = 0;
goto done;
}
else
isleep = SvIV(sleep); /* -sleep */
RETVAL = 0;
server = GetServer(servername);
if (server == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
goto done;
}
partition = volutil_GetPartitionID(parti);
if (partition < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", parti);
VSETCODE(ENOENT, buffer);
goto done;
}
volid = vsu_GetVolumeID(id, cstruct, &err); /* -id */
if (!volid) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "Unknown volume ID or name '%s'\n", servername);
VSETCODE(err ? err : -1, buffer);
goto done;
}
transflag = (ibusy ? ITBusy : ITOffline);
transdone = (isleep ? 0 /*online */ : VTOutOfService);
if (ibusy && !isleep) {
char buffer[256];
sprintf(buffer, "SLEEP argument must be used with BUSY flag\n");
VSETCODE(-1, buffer);
goto done;
}
code = UV_SetVolume(server, partition, volid, transflag, transdone, isleep);
if (code) {
char buffer[256];
sprintf(buffer, "Failed to set volume. Code = %d\n", code);
VSETCODE(code, buffer);
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vos_online(cstruct, servername, parti, id)
AFS::VOS cstruct
char* servername
char* parti
char *id
PREINIT:
int32 server, partition, volid;
int32 code, err=0;
CODE:
{
RETVAL = 0;
server = GetServer(servername);
if (server == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
goto done;
}
partition = volutil_GetPartitionID(parti);
if (partition < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", parti);
VSETCODE(ENOENT, buffer);
goto done;
}
volid = vsu_GetVolumeID(id, cstruct, &err); /* -id */
if (!volid) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "Unknown volume ID or name '%s'\n", servername);
VSETCODE(err ? err : -1, buffer);
goto done;
}
code = UV_SetVolume(server, partition, volid, ITOffline, 0 /*online */ , 0 /*sleep */ );
if (code) {
char buffer[256];
sprintf(buffer, "Failed to set volume. Code = %d\n", code);
VSETCODE(code, buffer);
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
void
vos__backupsys(cstruct, seenprefix=Nullsv, servername=NULL, partition=NULL, exclude=Nullsv, seenxprefix=Nullsv, noaction=Nullsv)
AFS::VOS cstruct
SV * seenprefix
char *servername
char *partition
SV * exclude
SV * seenxprefix
SV * noaction
PREINIT:
int32 apart=0, avolid;
int32 aserver=0, code, aserver1, apart1;
int32 vcode, iexclude=0, inoaction=0;
struct VldbListByAttributes attributes;
nbulkentries arrayEntries;
register struct nvldbentry *vllist;
int32 nentries;
int j, i, len, verbose = 1;
afs_int32 totalBack=0;
afs_int32 totalFail=0;
int previdx=-1, error, same;
char *ccode, *itp;
int match = 0;
STRLEN prfxlength=0;
SV *regex;
AV *av;
AV *av1 = (AV*)sv_2mortal((SV*)newAV());
AV *av2 = (AV*)sv_2mortal((SV*)newAV());
PPCODE:
{
/* printf("vos-backupsys DEBUG-1 server %s part %s exclude %d noaction %d \n", servername, partition, (int)SvIV(exclude), (int)SvIV(noaction)); */
if (!exclude)
exclude = newSViv(0);
if (!noaction)
noaction = newSViv(0);
if ((!SvIOKp(exclude))) {
char buffer[256];
sprintf(buffer, "Flag \"exclude\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
XSRETURN_UNDEF;
}
else
iexclude = SvIV(exclude); /* -exclude */
/* printf("vos-backupsys DEBUG-2: iexclude = %d \n", iexclude); */
if ((!SvIOKp(noaction))) {
char buffer[256];
sprintf(buffer, "Flag \"noaction\" should be numeric.\n");
VSETCODE(EINVAL, buffer);
XSRETURN_UNDEF;
}
else
inoaction = SvIV(noaction); /* -noaction */
Zero(&attributes, 1, VldbListByAttributes);
attributes.Mask = 0;
/* printf("vos-backupsys DEBUG-3\n"); */
if (servername && (strlen(servername) != 0)) { /* -server */
/* printf("vos-backupsys DEBUG-4\n"); */
aserver = GetServer(servername);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
attributes.server = ntohl(aserver);
attributes.Mask |= VLLIST_SERVER;
}
else {
servername = NULL;
}
/* printf("vos-backupsys DEBUG-5\n"); */
if (partition && (strlen(partition) != 0)) { /* -partition */
/* printf("vos-backupsys DEBUG-6\n"); */
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: could not interpret partition name '%s'\n", partition);
VSETCODE(-1, buffer);
itp = SvPV_nolen(regex);
if (strncmp(itp, "^", 1) == 0) {
ccode = (char *) re_comp(itp);
if (ccode) {
char buffer[256];
sprintf(buffer, "Error in PREFIX regular expression: '%s': %s\n",
itp, ccode);
VSETCODE(ccode, buffer);
XSRETURN_UNDEF;
}
if (re_exec(vllist->name) == 1) {
match = 0;
break;
}
}
else {
if (strncmp(vllist->name, itp, strlen(itp)) == 0) {
match = 0;
break;
}
}
}
}
/* printf("vos-backupsys DEBUG-16-1: exclude %d match %d\n", iexclude, match); */
if (iexclude)
match = !match; /* -exclude will reverse the match */
if (!match)
continue; /* Skip if no match */
/* printf("vos-backupsys DEBUG-16-2: noaction %d match %d\n", inoaction, match); */
/* Print list of volumes to backup */
if (inoaction) {
av_push(av1, newSVpv(vllist->name, strlen(vllist->name)));
continue;
}
/* printf("vos-backupsys DEBUG-17\n"); */
if (!(vllist->flags & RW_EXISTS)) {
if (verbose) {
fprintf(STDOUT, "Omitting to backup %s since RW volume does not exist \n",
vllist->name);
fprintf(STDOUT, "\n");
}
fflush(STDOUT);
continue;
}
/* printf("vos-backupsys DEBUG-18\n"); */
avolid = vllist->volumeId[RWVOL];
MapHostToNetwork(vllist);
GetServerAndPart(vllist, RWVOL, &aserver1, &apart1, &previdx);
if (aserver1 == -1 || apart1 == -1) {
av_push(av2, newSVpv(vllist->name, strlen(vllist->name)));
fprintf(STDOUT, "could not backup %s, invalid VLDB entry\n", vllist->name);
totalFail++;
continue;
}
/* printf("vos-backupsys DEBUG-19\n"); */
if (aserver) {
same = VLDB_IsSameAddrs(aserver, aserver1, &error);
if (error) {
av_push(av2, newSVpv(vllist->name, strlen(vllist->name)));
fprintf(stderr,
"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",
aserver, error);
totalFail++;
continue;
}
}
/* printf("vos-backupsys DEBUG-20\n"); */
if ((aserver && !same) || (apart && (apart != apart1))) {
if (verbose) {
fprintf(STDOUT,
"Omitting to backup %s since the RW is in a different location\n",
vllist->name);
}
continue;
}
if (verbose) {
time_t now = time(0);
fprintf(STDOUT, "Creating backup volume for %s on %s", vllist->name, ctime(&now));
fflush(STDOUT);
}
/* printf("vos-backupsys DEBUG-21\n"); */
code = UV_BackupVolume(aserver1, apart1, avolid);
if (code) {
av_push(av2, newSVpv(vllist->name, strlen(vllist->name)));
fprintf(STDOUT, "Could not backup %s\n", vllist->name);
totalFail++;
}
else {
av_push(av1, newSVpv(vllist->name, strlen(vllist->name)));
totalBack++;
}
} /* process each vldb entry */
/* printf("vos-backupsys DEBUG-22: Succ %d Fail %d\n", totalBack, totalFail); */
if (arrayEntries.nbulkentries_val)
free(arrayEntries.nbulkentries_val);
SETCODE(0);
XPUSHs(sv_2mortal(newRV_inc((SV *) (av1))));
XPUSHs(sv_2mortal(newRV_inc((SV *) (av2))));
XSRETURN(2);
}
void
vos_listpart(cstruct, server)
AFS::VOS cstruct
char *server
PREINIT:
int32 aserver, code;
struct partList dummyPartList;
int i, total, cnt;
char pname[10];
PPCODE:
{
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VOS: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
code = UV_ListPartitions(aserver, &dummyPartList, &cnt);
if (code) {
PrintDiagnostics("listpart", code);
XSRETURN_UNDEF;
}
total = 0;
for (i = 0; i < cnt; i++) {
if (dummyPartList.partFlags[i] & PARTVALID) {
Zero(pname, 10, char);
MapPartIdIntoName(dummyPartList.partId[i], pname);
XPUSHs(sv_2mortal(newSVpv(pname, strlen(pname))));
total++;
}
}
SETCODE(0);
XSRETURN(total);
}
void
vos_listvolume(cstruct, name)
AFS::VOS cstruct
char *name
PREINIT:
struct nvldbentry entry;
afs_int32 vcode = 0;
volintInfo *pntr = (volintInfo *)0;
afs_int32 volid;
afs_int32 code, err;
int voltype, foundserv = 0, foundentry = 0;
afs_int32 aserver, apart;
char apartName[10];
int previdx = -1;
HV *volinfo = (HV*)sv_2mortal((SV*)newHV());
PPCODE:
{
volid = vsu_GetVolumeID(name, cstruct, &err); /* -id */
if (volid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "Unknown volume ID or name '%s'\n", name);
VSETCODE(err ? err : -1, buffer);
XSRETURN_UNDEF;
}
vcode = VLDB_GetEntryByID(volid, -1, &entry);
if (vcode) {
char buffer[256];
sprintf(buffer, "Could not fetch the entry for volume number %u from VLDB \n", volid);
VSETCODE(vcode, buffer);
XSRETURN_UNDEF;
}
MapHostToNetwork(&entry);
if (entry.volumeId[RWVOL] == volid)
voltype = RWVOL;
else if (entry.volumeId[BACKVOL] == volid)
voltype = BACKVOL;
else /* (entry.volumeId[ROVOL] == volid) */
voltype = ROVOL;
do { /* do {...} while (voltype == ROVOL) */
/* Get the entry for the volume. If its a RW vol, get the RW entry.
* It its a BK vol, get the RW entry (even if VLDB may say the BK doen't exist).
* If its a RO vol, get the next RO entry.
*/
GetServerAndPart(&entry, ((voltype == ROVOL) ? ROVOL : RWVOL), &aserver, &apart,
&previdx);
if (previdx == -1) { /* searched all entries */
if (!foundentry) {
char buffer[256];
sprintf(buffer, "Volume %s does not exist in VLDB\n\n", name);
VSETCODE(ENOENT, buffer);
XSRETURN_UNDEF;
}
break;
}
foundentry = 1;
/* Get information about the volume from the server */
code = UV_ListOneVolume(aserver, apart, volid, &pntr);
if (code) {
char buffer[256];
if (code == ENODEV) {
if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
/* The VLDB says there is no backup volume and its not on disk */
sprintf(buffer, "Volume %s does not exist\n", name);
}
else {
sprintf(buffer,
"Volume does not exist on server %s as indicated by the VLDB\n",
hostutil_GetNameByINet(aserver));
}
}
else {
sprintf(buffer, "examine");
}
if (pntr)
free(pntr);
VSETCODE(code, buffer);
XSRETURN_UNDEF;
}
else {
int timeout
int noauth
int localauth
char * tcell
int crypt
PREINIT:
int32 code = -1;
extern int verbose;
PPCODE:
{
if (tcell && (tcell[0] == '\0' || tcell[0] == '0'))
tcell = NULL;
/* Initialize the ubik_client connection */
rx_SetRxDeadTime(timeout); /* timeout seconds inactivity before declared dead */
cstruct = (struct ubik_client *) 0;
verbose = verb;
if (crypt) /* -crypt specified */
vsu_SetCrypt(1);
code = internal_vsu_ClientInit((noauth != 0),
AFSDIR_CLIENT_ETC_DIRPATH, tcell, localauth,
&cstruct, UV_SetSecurity);
if (code == 0) {
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "AFS::VLDB", (void *) cstruct);
XSRETURN(1);
}
else
XSRETURN_UNDEF;
}
int32
vldb__DESTROY(self)
AFS::VLDB self
PREINIT:
int32 code = 0;
CODE:
{
code = ubik_ClientDestroy(self);
/* printf("DEBUG-23 %d \n", code); */
SETCODE(code);
/* printf("DEBUG-24 \n"); */
RETVAL = (code == 0);
/* printf("DEBUG-25 \n"); */
}
OUTPUT:
RETVAL
int32
vldb_addsite(cstruct, server, partition, id, roid=NULL, valid=0)
AFS::VLDB cstruct
char *server
char *partition
char *id
char *roid
int valid
PREINIT:
int32 code = 1;
CODE:
{
afs_int32 avolid, aserver, apart, err, arovolid=0;
char avolname[VOLSER_MAXVOLNAME + 1];
if (roid && (roid[0] == '\0' || roid[0] == '0'))
roid = NULL;
RETVAL = 0;
/* printf("vldb_addsite DEBUG-1 server %s part %s Vol/Id %s RO-Vol/ID %s ValID %d \n", server, partition, id, roid, valid); */
#ifdef OpenAFS_1_4
vsu_ExtractName(avolname, id);
#else
strcpy(avolname, id);
#endif
/* printf("vldb_addsite DEBUG-2 id %s avolname %s \n", id, avolname); */
avolid = vsu_GetVolumeID(avolname, cstruct, &err);
/* printf("vldb_addsite DEBUG-3 Vol-Nam %s Vol-ID %d \n", avolname, avolid); */
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
goto done;
}
#ifdef OpenAFS_1_4_12
if (roid) {
/* printf("vldb_addsite DEBUG-4 Roid %s AROVolid %d\n", roid, arovolid); */
vsu_ExtractName(avolname, roid);
arovolid = vsu_GetVolumeID(avolname, cstruct, &err);
/* printf("vldb_addsite DEBUG-5 Roid %s AROVolid %d\n", roid, arovolid); */
if (!arovolid) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: invalid ro volume id '%s'\n", roid);
VSETCODE(-1, buffer);
goto done;
}
}
#endif
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
goto done;
}
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n", partition);
VSETCODE(-1, buffer);
goto done;
}
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VLDB: partition %s does not exist on the server\n",
partition);
VSETCODE(code ? code : -1, buffer);
goto done;
}
#if defined(OpenAFS_1_4_12)
code = UV_AddSite2(aserver, apart, avolid, arovolid, valid);
#else
#if defined(OpenAFS_1_4_07)
code = UV_AddSite(aserver, apart, avolid, valid);
#else
code = UV_AddSite(aserver, apart, avolid);
#endif
#endif
if (code) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: addsite didn't work\n");
VSETCODE(code, buffer);
goto done;
}
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb_changeloc(cstruct, id, server, partition)
AFS::VLDB cstruct
char *id
char *server
char *partition
PREINIT:
#ifdef OpenAFS
afs_int32 avolid, aserver, apart, code, err;
#endif
CODE:
{
#ifdef OpenAFS
/* printf("DEBUG-1\n"); */
RETVAL = 0;
avolid = vsu_GetVolumeID(id, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
goto done;
}
/* printf("DEBUG-2\n"); */
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
goto done;
}
/* printf("DEBUG-3\n"); */
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n", partition);
VSETCODE(-1, buffer);
/* printf("DEBUG-3.1\n"); */
goto done;
}
/* printf("DEBUG-4\n"); */
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VLDB: partition %s does not exist on the server\n", server);
VSETCODE(code ? code : -1, buffer);
goto done;
}
/* printf("DEBUG-5\n"); */
code = UV_ChangeLocation(aserver, apart, avolid);
if (code) {
VSETCODE(code, "changeloc");
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
#else
not_here("AFS::VLDB::changeloc");
#endif
}
OUTPUT:
RETVAL
void
vldb__listvldb(cstruct, name=NULL, servername=NULL, parti=NULL, lock=0)
AFS::VLDB cstruct
char *name
char *servername
char *parti
int lock
PREINIT:
afs_int32 apart;
afs_int32 aserver, code;
afs_int32 vcode;
struct VldbListByAttributes attributes;
nbulkentries arrayEntries;
struct nvldbentry *vllist;
afs_int32 centries, nentries = 0;
int j;
afs_int32 thisindex, nextindex;
HV *status, *stats;
PPCODE:
{
status = (HV *) sv_2mortal((SV *) newHV());
if (name && strlen(name) == 0)
name = NULL;
if (servername && strlen(servername) == 0)
servername = NULL;
if (parti && strlen(parti) == 0)
parti = NULL;
/* printf("DEBUG-0 name %s, server %s, part %s lock %d \n", name, servername, parti, */
aserver = 0;
apart = 0;
attributes.Mask = 0;
/* printf("DEBUG-1 \n"); */
/* If the volume name is given, Use VolumeInfoCmd to look it up
* and not ListAttributes.
*/
if (name) {
/* printf("DEBUG-2 \n"); */
if (lock) {
char buffer[256];
/* printf("DEBUG-3 \n"); */
sprintf(buffer,
"AFS::VLDB: illegal use of '-locked' switch, need to specify server and/or partition\n");
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
/* printf("DEBUG-4 \n"); */
stats = (HV *) sv_2mortal((SV *) newHV());
code = VolumeInfoCmd(stats, name);
if (code) {
char buffer[256];
set_errbuff(buffer, code);
VSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* printf("DEBUG-5 \n"); */
safe_hv_store(status, name, strlen(name), newRV_inc((SV *) (stats)), 0);
goto finish;
}
/* Server specified */
/* printf("DEBUG-6 \n"); */
if (servername) {
/* printf("DEBUG-7 \n"); */
aserver = GetServer(servername);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
attributes.server = ntohl(aserver);
attributes.Mask |= VLLIST_SERVER;
}
/* Partition specified */
/* printf("DEBUG-8 \n"); */
if (parti) {
/* printf("DEBUG-9 \n"); */
apart = volutil_GetPartitionID(parti);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n", parti);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
attributes.partition = apart;
attributes.Mask |= VLLIST_PARTITION;
}
/* printf("DEBUG-10 \n"); */
if (lock) {
/* printf("DEBUG-11 \n"); */
attributes.Mask |= VLLIST_FLAG;
attributes.flag = VLOP_ALLOPERS;
}
/* printf("DEBUG-12 \n"); */
for (thisindex = 0; (thisindex != -1); thisindex = nextindex) {
/* printf("DEBUG-13 \n"); */
/* memset(&arrayEntries, 0, sizeof(arrayEntries)); */
/* Zero(&arrayEntries, sizeof(arrayEntries), nbulkentries); ??? nog ??? */
Zero(&arrayEntries, 1, nbulkentries);
/* printf("DEBUG-14 \n"); */
centries = 0;
nextindex = -1;
vcode = VLDB_ListAttributesN2(&attributes, 0, thisindex,
¢ries, &arrayEntries, &nextindex);
/* printf("DEBUG-15 \n"); */
if (vcode == RXGEN_OPCODE) {
/* Vlserver not running with ListAttributesN2. Fall back */
j = 0;
while (1) {
HV *addr = (HV *) sv_2mortal((SV *) newHV());
m_attrs.index = i;
vcode = ubik_Call_New(VL_GetAddrsU, cstruct, 0, &m_attrs, &m_uuid,
&m_unique, &m_nentries, &m_addrs);
if (vcode == VL_NOENT) {
i++;
nentries++;
continue;
}
if (vcode == VL_INDEXERANGE) {
vcode = 0;
break;
}
if (vcode) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not list the server addresses\n");
VSETCODE(vcode, buffer);
XSRETURN_UNDEF;
}
myprint_addrs(addr, &m_addrs, &m_uuid, m_nentries, printuuid, noresolve);
XPUSHs(sv_2mortal(newRV_inc((SV *) (addr))));
i++;
j++;
if (host || uuid || (i > nentries))
break;
}
SETCODE(vcode);
XSRETURN(j);
}
void
vldb__delentry(cstruct, volume=NULL, prfx=NULL, server=NULL, partition=NULL, noexecute=0)
AFS::VLDB cstruct
SV* volume
char *prfx
char *server
char *partition
int noexecute
PREINIT:
afs_int32 apart;
afs_int32 avolid;
afs_int32 vcode = 0;
struct VldbListByAttributes attributes;
nbulkentries arrayEntries;
register struct nvldbentry *vllist;
SV *vol;
char *itp;
afs_int32 nentries;
int j;
char prefix[VOLSER_MAXVOLNAME+1];
int seenprefix=0;
STRLEN volumelength=0;
afs_int32 totalBack=0, totalFail=0, err;
AV *av;
PPCODE:
{
if (prfx && strlen(prfx) == 0)
prfx = NULL;
if (partition && strlen(partition) == 0)
partition = NULL;
if (server && strlen(server) == 0)
server = NULL;
if (volume && (volumelength = sv_len(volume)) == 0)
volume = NULL;
if (volume && (! (SvTYPE(SvRV(volume)) == SVt_PVAV))) {
VSETCODE(-1, "AFS::VLDB: VOLUME not array reference");
XSRETURN_UNDEF;
}
if (volume) { /* -id */
int len;
if (prfx || server || partition) {
VSETCODE(-1, "You cannot use SERVER, PARTITION, or PREFIX with the VOLUME argument");
XSRETURN_UNDEF;
}
av = (AV *) SvRV(volume);
len = av_len(av);
if (len != -1) {
for (j = 0; j <= len; j++) {
vol = *av_fetch(av, j, 0);
itp = SvPV_nolen(vol);
if (itp) {
avolid = vsu_GetVolumeID(itp, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", itp);
VSETCODE(err ? err : -1, buffer);
continue;
}
if (noexecute) { /* -noexecute */
fprintf(STDOUT, "Would have deleted VLDB entry for %s \n", itp);
fflush(STDOUT);
continue;
}
vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, RWVOL);
if (vcode) {
char buffer[256];
sprintf(buffer, "Could not delete entry for volume %s\n"
"You must specify a RW volume name or ID "
"(the entire VLDB entry will be deleted)\n", itp);
VSETCODE(vcode, buffer);
totalFail++;
continue;
}
totalBack++;
}
} /* for */
} /* len */
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSViv(totalBack)));
PUSHs(sv_2mortal(newSViv(totalFail)));
goto done;
} /* id */
if (!prfx && !server && !partition) {
VSETCODE(-1, "You must specify an argument");
XSRETURN_UNDEF;
}
/* Zero out search attributes */
Zero(&attributes, 1, VldbListByAttributes);
if (prfx) { /* -prefix */
strncpy(prefix, prfx, VOLSER_MAXVOLNAME);
seenprefix = 1;
if (!server && !partition) { /* a single entry only */
VSETCODE(-1, "You must provide SERVER with the PREFIX argument");
XSRETURN_UNDEF;
}
}
if (server) { /* -server */
afs_int32 aserver;
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
attributes.server = ntohl(aserver);
attributes.Mask |= VLLIST_SERVER;
}
if (partition) { /* -partition */
if (!server) {
VSETCODE(-1, "You must provide SERVER with the PARTITION argument");
#}
#fprintf(STDOUT, "\n");
#fflush(STDOUT);
/* Get all the VLDB entries on a server and/or partition */
Zero(&arrayEntries, 1, nbulkentries);
vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
if (vcode) {
VSETCODE(vcode, "Could not access the VLDB for attributes");
XSRETURN_UNDEF;
}
/* Process each entry */
for (j = 0; j < nentries; j++) {
vllist = &arrayEntries.nbulkentries_val[j];
if (seenprefix) {
/* It only deletes the RW volumes */
if (strncmp(vllist->name, prefix, strlen(prefix))) {
fflush(STDOUT);
continue;
}
}
if (noexecute) { /* -noexecute */
fprintf(STDOUT, "Would have deleted VLDB entry for %s \n", vllist->name);
fflush(STDOUT);
continue;
}
/* Only matches the RW volume name */
avolid = vllist->volumeId[RWVOL];
vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, RWVOL);
if (vcode) {
fprintf(STDOUT, "Could not delete VDLB entry for %s\n", vllist->name);
totalFail++;
PrintError("", vcode);
continue;
}
else {
totalBack++;
}
fflush(STDOUT);
} /*for */
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSViv(totalBack)));
PUSHs(sv_2mortal(newSViv(totalFail)));
if (arrayEntries.nbulkentries_val)
free(arrayEntries.nbulkentries_val);
done:
;
}
int32
vldb_lock(cstruct, id)
AFS::VLDB cstruct
char *id
PREINIT:
afs_int32 avolid, vcode, err;
CODE:
{
RETVAL = 0;
avolid = vsu_GetVolumeID(id, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
goto done;
}
vcode = ubik_Call(VL_SetLock, cstruct, 0, avolid, -1, VLOP_DELETE);
if (vcode) {
char buffer[256];
sprintf(buffer, "Could not lock VLDB entry for volume %s\n", id);
VSETCODE(vcode, buffer);
goto done;
}
/* fprintf(STDOUT, "Locked VLDB entry for volume %s\n", id); */
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb_unlock(cstruct, id)
AFS::VLDB cstruct
char *id
PREINIT:
afs_int32 avolid, code, err;
CODE:
{
RETVAL = 0;
avolid = vsu_GetVolumeID(id, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", id);
VSETCODE(err ? err : -1, buffer);
goto done;
}
code = UV_LockRelease(avolid);
if (code) {
VSETCODE(code, "unlock");
goto done;
}
/* fprintf(STDOUT,"Released lock on vldb entry for volume %s\n",id); */
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb_unlockvldb(cstruct, server=NULL, partition=NULL)
AFS::VLDB cstruct
char *server
char *partition
PREINIT:
afs_int32 apart = -1;
afs_int32 aserver = 0,code;
afs_int32 vcode;
struct VldbListByAttributes attributes;
nbulkentries arrayEntries;
register struct nvldbentry *vllist;
afs_int32 nentries;
int j;
afs_int32 volid;
afs_int32 totalE = 0;
CODE:
{
RETVAL = 0;
attributes.Mask = 0;
if (server && (strlen(server) != 0)) { /* server specified */
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
goto done;
}
attributes.server = ntohl(aserver);
attributes.Mask |= VLLIST_SERVER;
}
if (partition && (strlen(partition) != 0)) { /* partition specified */
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n",
partition);
VSETCODE(-1, buffer);
goto done;
}
if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VLDB: partition %s does not exist on the server\n",
partition);
VSETCODE(code ? code : -1, buffer);
goto done;
}
attributes.partition = apart;
attributes.Mask |= VLLIST_PARTITION;
}
attributes.flag = VLOP_ALLOPERS;
attributes.Mask |= VLLIST_FLAG;
Zero(&arrayEntries, 1, nbulkentries); /*initialize to hint the stub to alloc space */
vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
if (vcode) {
char buffer[256];
sprintf(buffer, "Could not access the VLDB for attributes\n");
VSETCODE(vcode, buffer);
goto done;
}
for (j = 0; j < nentries; j++) { /* process each entry */
vllist = &arrayEntries.nbulkentries_val[j];
volid = vllist->volumeId[RWVOL];
vcode =
ubik_Call(VL_ReleaseLock, cstruct, 0, volid, -1,
LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
if (vcode) {
char buffer[256];
sprintf(buffer, "Could not unlock entry for volume %s\n", vllist->name);
VSETCODE(vcode, buffer);
totalE++;
}
}
if (totalE)
fprintf(STDOUT, "Could not unlock %u VLDB entries of %u locked entries\n", totalE,
nentries);
if (arrayEntries.nbulkentries_val)
free(arrayEntries.nbulkentries_val);
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb__syncvldb(cstruct, server=NULL, partition=NULL, volname=NULL)
AFS::VLDB cstruct
char *server
char *partition
char *volname
PREINIT:
afs_int32 pname = 0, code; /* part name */
int flags = 0;
afs_int32 tserver = 0;
CODE:
{
RETVAL = 0;
/* printf("server %s, part %s volume %s \n", server, partition, volname); */
if (server && (strlen(server) != 0)) {
tserver = GetServer(server);
if (!tserver) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: host '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
goto done;
}
}
if (partition && (strlen(partition) != 0)) {
pname = volutil_GetPartitionID(partition);
if (pname < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n",
partition);
VSETCODE(-1, buffer);
goto done;
}
if (!tserver) {
char buffer[256];
sprintf(buffer, "The PARTITION argument requires a SERVER argument\n");
VSETCODE(-1, buffer);
goto done;
}
if (!IsPartValid(pname, tserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VLDB: partition %s does not exist on the server\n",
partition);
VSETCODE(code ? code : -1, buffer);
goto done;
}
flags = 1;
}
if (volname && (strlen(volname) != 0)) {
/* Synchronize an individual volume */
code = UV_SyncVolume(tserver, pname, volname, flags);
}
else {
if (!tserver) {
char buffer[256];
sprintf(buffer, "Without a VOLUME argument, the server argument is required\n");
VSETCODE(-1, buffer);
goto done;
}
code = UV_SyncVldb(tserver, pname, flags, 0 /*unused */ );
}
if (code) {
char buffer[256];
set_errbuff(buffer, code);
VSETCODE(code, buffer);
#PrintDiagnostics("syncvldb", code);
#SETCODE(code);
goto done;
}
else
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb__changeaddr(cstruct, oldip, newip, remove=0)
AFS::VLDB cstruct
char *oldip
char *newip
int32 remove
PREINIT:
int32 ip1, ip2, vcode;
CODE:
{
RETVAL = 0;
ip1 = GetServer(oldip);
if (!ip1) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: invalid host address\n");
VSETCODE(EINVAL, buffer);
goto done;
}
if ((newip && (strlen(newip)) && remove) || (!newip && !remove)) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: Must specify either 'NEWADDR <addr>' or 'REMOVE' flag\n");
VSETCODE(EINVAL, buffer);
goto done;
}
if (newip && (strlen(newip)) != 0) {
ip2 = GetServer(newip);
if (!ip2) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: invalid host address\n");
VSETCODE(EINVAL, buffer);
goto done;
}
}
else {
/* Play a trick here. If we are removing an address, ip1 will be -1
* and ip2 will be the original address. This switch prevents an
* older revision vlserver from removing the IP address.
*/
remove = 1;
ip2 = ip1;
ip1 = 0xffffffff;
}
vcode = ubik_Call_New(VL_ChangeAddr, cstruct, 0, ntohl(ip1), ntohl(ip2));
if (vcode) {
char buffer[256];
if (remove) {
char buff[80];
sprintf(buff, "Could not remove server %s from the VLDB", oldip);
if (vcode == VL_NOENT) {
sprintf(buffer, "%s\nvlserver does not support the REMOVE flag or VLDB: no such entry", buff);
}
else {
sprintf(buffer, "%s\n", buff);
}
}
else {
sprintf(buffer, "Could not change server %s to server %s\n", oldip, newip);
}
VSETCODE(vcode, buffer);
goto done;
}
if (remove) {
fprintf(STDOUT, "Removed server %s from the VLDB\n", oldip);
}
else {
fprintf(STDOUT, "Changed server %s to server %s\n", oldip, newip);
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb_remsite(cstruct,server,partition,name)
AFS::VLDB cstruct
char *server
char *partition
char *name
PREINIT:
afs_int32 avolid, aserver, apart, code = 1, err;
char avolname[VOLSER_MAXVOLNAME + 1];
CODE:
{
RETVAL = 0;
#ifdef OpenAFS_1_4
vsu_ExtractName(avolname, name);
#else
strcpy(avolname, name);
#endif
avolid = vsu_GetVolumeID(avolname, cstruct, &err);
if (avolid == 0) {
char buffer[256];
if (err)
set_errbuff(buffer, err);
else
sprintf(buffer, "AFS::VLDB: can't find volume '%s'\n", avolname);
VSETCODE(err ? err : -1, buffer);
goto done;
}
aserver = GetServer(server);
if (aserver == 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: server '%s' not found in host table\n", server);
VSETCODE(-1, buffer);
goto done;
}
apart = volutil_GetPartitionID(partition);
if (apart < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n", partition);
VSETCODE(-1, buffer);
goto done;
}
code = UV_RemoveSite(aserver, apart, avolid);
printf("\n");
if (code) {
PrintDiagnostics("remsite", code);
SETCODE(code);
goto done;
}
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
int32
vldb_syncserv(cstruct, servername, parti=NULL)
AFS::VLDB cstruct
char *servername
char *parti
PREINIT:
afs_int32 pname = 0, code; /* part name */
afs_int32 tserver;
int flags = 0;
CODE:
{
RETVAL = 0;
tserver = GetServer(servername);
if (!tserver) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: host '%s' not found in host table\n", servername);
VSETCODE(-1, buffer);
goto done;
}
if (parti && (strlen(parti) != 0)) {
pname = volutil_GetPartitionID(parti);
if (pname < 0) {
char buffer[256];
sprintf(buffer, "AFS::VLDB: could not interpret partition name '%s'\n", parti);
VSETCODE(-1, buffer);
goto done;
}
if (!IsPartValid(pname, tserver, &code)) { /*check for validity of the partition */
char buffer[256];
if (code)
set_errbuff(buffer, code);
else
sprintf(buffer, "AFS::VLDB: partition %s does not exist on the server\n",
parti);
VSETCODE(code ? code : -1, buffer);
goto done;
}
flags = 1;
}
code = UV_SyncServer(tserver, pname, flags, 0 /*unused */ );
if (code) {
PrintDiagnostics("syncserv", code);
SETCODE(code);
goto done;
}
SETCODE(0);
RETVAL = 1;
done:
;
}
OUTPUT:
RETVAL
MODULE = AFS PACKAGE = AFS::BOS PREFIX = bos_
AFS::BOS
bos_new(class=0, servname, noauth=0, localauth=0, cell=0, aencrypt=1)
char * class
char *servname
int noauth
int localauth
char *cell
int aencrypt
PREINIT:
int32 code = -1;
AFS__BOS server;
PPCODE:
{
/* printf("bos new DEBUG-1 \n"); */
if (cell && (cell[0] == '\0' || cell[0] == '0'))
cell = NULL;
/* printf("bos new call internal_new DEBUG-2 \n"); */
server = internal_bos_new(&code, servname, localauth, noauth, aencrypt, cell);
/* SETCODE(code); */
/* printf("bos new return internal_new DEBUG-3 \n"); */
if (code == 0) {
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "AFS::BOS", (void *) server);
XSRETURN(1);
}
else
XSRETURN_UNDEF;
}
int32
int32 code = 0;
struct ktime generalTime, newBinaryTime;
char messageBuffer[256];
PPCODE:
{
code = BOZO_GetRestartTime(self, 1, &generalTime);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve restart information (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
code = BOZO_GetRestartTime(self, 2, &newBinaryTime);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve restart information (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
code = ktime_DisplayString(&generalTime, messageBuffer);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to decode restart time (%s)\n", em(code));
BSETCODE(code, buffer);
strcpy(messageBuffer, "");
}
XPUSHs(sv_2mortal(newSVpv(messageBuffer, strlen(messageBuffer))));
code = ktime_DisplayString(&newBinaryTime, messageBuffer);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to decode restart time (%s)\n", em(code));
BSETCODE(code, buffer);
strcpy(messageBuffer, "");
}
XPUSHs(sv_2mortal(newSVpv(messageBuffer, strlen(messageBuffer))));
XSRETURN(2);
}
void
bos_listusers(self)
AFS::BOS self
PREINIT:
int i;
int32 code = 0;
char tbuffer[256];
char *tp;
PPCODE:
{
for (i = 0;; i++) {
tp = tbuffer;
code = BOZO_ListSUsers(self, i, &tp);
if (code)
break;
XPUSHs(sv_2mortal(newSVpv(tbuffer, strlen(tbuffer))));
}
if (code != 1) {
/* a real error code, instead of scanned past end */
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve super-user list (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
else {
SETCODE(0);
XSRETURN(i);
}
}
void
bos_listhosts(self)
AFS::BOS self
PREINIT:
int32 i, code = 0;
char tbuffer[256];
char *tp;
AV *av = (AV*)sv_2mortal((SV*)newAV());
PPCODE:
{
tp = tbuffer;
code = BOZO_GetCellName(self, &tp);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to get cell name (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* printf("Cell name is %s\n", tbuffer); */
XPUSHs(sv_2mortal(newSVpv(tbuffer, strlen(tbuffer))));
for (i = 0;; i++) {
code = BOZO_GetCellHost(self, i, &tp);
if (code == BZDOM)
break;
if (code != 0) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to get cell host %d (%s)\n", i, em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* printf(" Host %d is %s\n", i+1, tbuffer); */
av_push(av, newSVpv(tbuffer, strlen(tbuffer)));
}
XPUSHs(sv_2mortal(newRV_inc((SV *) (av))));
SETCODE(0);
XSRETURN(2);
}
int32
bos_delete(self, object)
AFS::BOS self
SV* object
PREINIT:
int32 code = 0, len, i;
AV *av; SV *sv;
char *name;
if (code == BZBUSY)
sprintf(buffer, "AFS::BOS: can't delete running instance '%s'\n", name);
else
sprintf(buffer, "AFS::BOS: failed to delete instance '%s' (%s)\n", name,
em(code));
BSETCODE(code, buffer);
/* printf("DEBUG-bos-delete-4 %s \n", buffer); */
goto done;
}
}
else if (SvTYPE(SvRV(object)) == SVt_PVAV) {
/* printf("DEBUG-bos-delete-5 \n"); */
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
/* printf("DEBUG-bos-delete-6 \n"); */
for (i = 0; i <= len; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
name = (char *) safemalloc(BOZO_BSSIZE);
name = SvPV(sv, namelen);
/* printf("DEBUG-bos-delete-7 %s\n", name); */
code = BOZO_DeleteBnode(self, name);
/* printf("DEBUG-bos-delete-8 %d \n", code); */
if (code) {
char buffer[256];
if (code == BZBUSY)
sprintf(buffer, "AFS::BOS: can't delete running instance '%s'\n",
name);
else
sprintf(buffer, "AFS::BOS: failed to delete instance '%s' (%s)\n",
name, em(code));
BSETCODE(code, buffer);
goto done;
}
}
} /* for loop */
}
}
SETCODE(0);
/* printf("DEBUG-bos-delete-9 \n"); */
done:
RETVAL = (code == 0);
/* printf("DEBUG-bos-delete-10 \n"); */
/* if (name) */
/* Safefree(name); */
/* printf("DEBUG-bos-delete-11 \n"); */
}
OUTPUT:
RETVAL
void
bos_getlog(self, file)
AFS::BOS self
char* file
PREINIT:
register struct rx_call *tcall;
int32 code = 0;
char buf, c[255];
int error, num = 0, i = 0;
PPCODE:
{
tcall = rx_NewCall(self);
code = StartBOZO_GetLog(tcall, file);
if (code) {
char buffer[256];
rx_EndCall(tcall, code);
sprintf(buffer, "AFS::BOS error %d (while reading log)\n", code);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* copy data */
error = 0;
while (1) {
code = rx_Read(tcall, &buf, 1);
if (code != 1) {
error = EIO;
break;
}
if (buf == 0)
break; /* the end delimeter */
/* putchar(buf); */
c[i++] = buf;
if (buf == '\n') {
XPUSHs(sv_2mortal(newSVpv(c, i)));
i = 0;
num++;
}
}
code = rx_EndCall(tcall, error);
#if (tcall)
# Safefree(tcall);
/* fall through into cleanup code */
XSRETURN(num);
}
int32
bos__start(self, object=NULL)
AFS::BOS self
SV * object
PREINIT:
int32 code = 0;
CODE:
{
if (object && (! (SvTYPE(SvRV(object)) == SVt_PVAV))) {
code = -1;
BSETCODE(code, "AFS::BOS: SERVER not an array reference\n");
goto done;
}
if (object && (SvTYPE(SvRV(object)) == SVt_PVAV)) {
AV *av;
SV *sv;
char *instance;
STRLEN namelen;
int i, len;
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
/* instance = (char *) safemalloc(BOZO_BSSIZE); */
Newx(instance, BOZO_BSSIZE, char);
instance = SvPV(sv, namelen);
code = BOZO_SetStatus(self, instance, BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to start instance %s (%s)\n",
instance, em(code));
BSETCODE(code, buffer);
goto done;
}
/*if (instance) */
/* Safefree(instance); */
}
} /* for loop */
}
}
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
bos__startup(self, object=NULL)
OUTPUT:
RETVAL
int32
bos_setcellname(self, name)
AFS::BOS self
char *name
PREINIT:
int32 code = 0;
CODE:
{
not_here("AFS::BOS::setcellname");
code = BOZO_SetCellName(self, name);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to set cell (%s)\n", em(code));
BSETCODE(code, buffer);
}
}
OUTPUT:
RETVAL
void
bos_listkeys(self, showkey=0)
AFS::BOS self
int showkey
PREINIT:
afs_int32 i, kvno, code = 0;
struct ktc_encryptionKey tkey;
struct bozo_keyInfo keyInfo;
int everWorked = 0;
char index[5];
HV *list = (HV*)sv_2mortal((SV*)newHV());
PPCODE:
{
for (i = 0;; i++) {
HV *key = (HV *) sv_2mortal((SV *) newHV());
code = BOZO_ListKeys(self, i, &kvno, &tkey, &keyInfo);
if (code)
break;
everWorked = 1;
/* first check if key is returned */
if ((!ka_KeyIsZero((char *) &tkey, sizeof(tkey))) && showkey) {
/* ka_PrintBytes ((char *)&tkey, sizeof(tkey)); */
safe_hv_store(key, "key", 3, newSVpv((char *) &tkey, sizeof(tkey)), 0);
}
else {
if (keyInfo.keyCheckSum == 0) { /* shouldn't happen */
/* printf ("key version is %d\n", kvno); */
}
else {
safe_hv_store(key, "keyCheckSum", 11, newSVuv(keyInfo.keyCheckSum), 0);
}
}
sprintf(index, "%d", kvno);
safe_hv_store(list, index, strlen(index), newRV_inc((SV *) (key)), 0);
} /* for loop */
if (everWorked) {
/* fprintf(stderr, "Keys last changed on %d.\n", keyInfo.mod_sec); */
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSViv(keyInfo.mod_sec)));
PUSHs(newRV_inc((SV *) (list)));
}
if (code != BZDOM) {
char buffer[256];
sprintf(buffer, "AFS::BOS: %s error encountered while listing keys\n", em(code));
BSETCODE(code, buffer);
}
else {
code = 0;
}
if (everWorked) {
XSRETURN(2);
}
else {
XSRETURN_EMPTY;
hv_undef(list);
}
}
int32
bos_getrestricted(self)
AFS::BOS self
CODE:
{
#ifdef BOS_RESTRICTED_MODE
int32 val, code;
RETVAL = 0;
code = BOZO_GetRestrictedMode(self, &val);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to get restricted mode (%s)\n", em(code));
BSETCODE(code, buffer);
}
RETVAL = val;
#else
RETVAL = 0;
not_here("AFS::BOS::getrestricted");
#endif
}
OUTPUT:
RETVAL
int32
bos_setrestricted(self, mode)
AFS::BOS self
char *mode
CODE:
{
#ifdef BOS_RESTRICTED_MODE
int32 val, code;
util_GetInt32(mode, &val);
code = BOZO_SetRestrictedMode(self, val);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to set restricted mode (%s)\n", em(code));
BSETCODE(code, buffer);
}
RETVAL = (code == 0);
#else
RETVAL = 0;
not_here("AFS::BOS::setrestricted");
#endif
}
OUTPUT:
if (SalvageRemote)
mrafsParm.OptSalvageRemote = 1;
if (SalvageArchival)
mrafsParm.OptSalvageArchival = 1;
if (IgnoreCheck)
mrafsParm.OptIgnoreCheck = 1;
if (ForceOnLine)
mrafsParm.OptForceOnLine = 1;
if (UseRootDirACL)
mrafsParm.OptUseRootDirACL = 1;
if (TraceBadLinkCounts)
mrafsParm.OptTraceBadLinkCounts = 1;
if (DontAskFS)
mrafsParm.OptDontAskFS = 1;
if (LogLevel)
mrafsParm.OptLogLevel = LogLevel;
if (rxdebug)
mrafsParm.OptRxDebug = 1;
if (Residencies) {
if (SalvageRemote || SalvageArchival) {
char buffer[256];
sprintf(buffer,
"Can't specify -Residencies with -SalvageRemote or -SalvageArchival\n");
BSETCODE(EINVAL, buffer);
goto done;
}
/* muss naeher ueberprueft werden !!! */
/* #if defined(OpenAFS_1_2) */
/* code = GetUInt32(Residencies, &mrafsParm.OptResidencies); */
/* #else */
/* #if defined(OpenAFS_1_3) || defined(OpenAFS_1_4) || defined(OpenAFS_1_5) */
/* code = util_GetUInt32(Residencies, &mrafsParm.OptResidencies); */
/* #endif */
/* #endif */
/* if (code) { */
/* char buffer[256]; */
/* sprintf(buffer, "AFS::BOS: '%d' is not a valid residency mask.\n", TraceBadLinkCounts); /\* this doesn't really make sense to me AW *\/ */
/* BSETCODE(code, buffer); */
/* goto done; */
/* } */
/* muss naeher ueberprueft werden !!! */
mrafsParm.OptResidencies = Residencies;
}
}
else {
if (debug || nowrite || force || oktozap || rootfiles || salvagedirs || blockreads ||
ListResidencies || SalvageRemote || SalvageArchival || IgnoreCheck ||
ForceOnLine || UseRootDirACL || TraceBadLinkCounts || DontAskFS || LogLevel ||
rxdebug || Residencies) {
char buffer[256];
sprintf(buffer, "Parameter only possible for MR-AFS fileserver.\n");
BSETCODE(-1, buffer);
goto done;
}
}
if (all) {
/* salvage whole enchilada */
curGoal = GetServerGoal(self, "fs");
if (curGoal == BSTAT_NORMAL) {
fprintf(stderr, "AFS::BOS: shutting down fs.\n");
code = BOZO_SetTStatus(self, "fs", BSTAT_SHUTDOWN);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to stop 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = BOZO_WaitAll(self); /* wait for shutdown to complete */
if (code) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: failed to wait for file server shutdown, continuing.\n");
BSETCODE(code, buffer);
}
}
/* now do the salvage operation */
/* fprintf(stderr, "Starting salvage of everything.\n"); */
rc = DoSalvage(self, (char *) 0, (char *) 0, outName, showlog, parallel, tmpDir,
orphans);
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: restarting fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
}
if (rc) {
code = rc;
goto done;
}
}
else if (!volume) {
if (!partition) {
char buffer[256];
sprintf(buffer, "AFS::BOS: must specify ALL switch to salvage all partitions.\n");
BSETCODE(-1, buffer);
goto done;
}
if (volutil_GetPartitionID(partition) < 0) {
/* can't parse volume ID, so complain before shutting down
* file server.
*/
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as partition ID.\n", partition);
BSETCODE(-1, buffer);
goto done;
}
curGoal = GetServerGoal(self, "fs");
/* salvage a whole partition (specified by parms[1]) */
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: shutting down fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_SHUTDOWN);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't stop 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = BOZO_WaitAll(self); /* wait for shutdown to complete */
if (code) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: failed to wait for file server shutdown, continuing.\n");
BSETCODE(code, buffer);
}
}
/* now do the salvage operation */
/* fprintf(stderr, "Starting salvage of partition %s.\n", partition); */
rc = DoSalvage(self, partition, (char *) 0,
outName, showlog, parallel, tmpDir, orphans);
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: restarting fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
}
if (rc) {
code = rc;
goto done;
}
}
else {
/* salvage individual volume (don't shutdown fs first), just use
* single-shot cron bnode. Must leave server running when using this
* option, since salvager will ask file server for the volume */
afs_int32 err;
const char *confdir;
confdir = (localauth ? AFSDIR_SERVER_ETC_DIRPATH : AFSDIR_CLIENT_ETC_DIRPATH);
code = internal_vsu_ClientInit( /* noauth */ 1, confdir, tmpname,
/* server auth */ 0, &cstruct, (int (*)()) 0);
if (code == 0) {
newID = vsu_GetVolumeID(volume, cstruct, &err);
if (newID == 0) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as volume name or ID\n",
volume);
BSETCODE(-1, buffer);
goto done;
}
sprintf(tname, "%u", newID);
}
else {
char buffer[256];
sprintf(buffer,
"AFS::BOS: can't initialize volume system client (code %d), trying anyway.\n",
code);
BSETCODE(code, buffer);
strncpy(tname, volume, sizeof(tname));
}
if (volutil_GetPartitionID(partition) < 0) {
/* can't parse volume ID, so complain before shutting down
* file server.
*/
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as partition ID.\n", partition);
BSETCODE(-1, buffer);
goto done;
}
/* fprintf(stderr, "Starting salvage of volume %d on partition %s.\n",
newID, partition); */
rc = DoSalvage(self, partition, tname, outName, showlog, parallel, tmpDir, orphans);
if (rc) {
code = rc;
goto done;
}
}
code = 0;
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
MODULE = AFS PACKAGE = AFS::PTS PREFIX = pts_
AFS::PTS
pts__new(class=0, sec=1, cell=0)
char * class
int32 sec
char * cell
PREINIT:
int32 code = -1;
AFS__PTS server;
PPCODE:
{
if (cell && (cell[0] == '\0' || cell[0] == '0'))
cell = NULL;
server = internal_pts_new(&code, sec, cell);
# SETCODE(code); wird tiefer gesetzt...
if (code == 0) {
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "AFS::PTS", (void *) server);
XSRETURN(1);
}
else
XSRETURN_UNDEF;
}
int32
pts__DESTROY(server)
AFS::PTS server
CODE:
{
int32 code;
/* printf("pts DEBUG ubik_ClientDestroy\n"); */
code = ubik_ClientDestroy(server);
SETCODE(code);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
void
KSETCODE(code, buffer);
safefree(t);
XSRETURN_UNDEF;
}
}
void
kas_ka_Authenticate(server,name,instance,service,key,start,end,pwexpires=-1)
AFS::KAS server
char * name
char * instance
int32 service
AFS::KTC_EKEY key
int32 start
int32 end
int32 pwexpires
PPCODE:
{
int32 code;
int32 pw;
struct ktc_token *t;
#if defined(AFS_3_4)
#else
char *cell = NULL;
#endif
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
#if defined(AFS_3_4)
code = ka_Authenticate(name, instance, server, service, key, start, end, t, &pw);
#else
if (cell == 0) {
cell = internal_GetLocalCell(&code);
if (code)
XSRETURN_UNDEF;
}
code = ka_Authenticate(name, instance, cell, server, service, key, start, end, t, &pw);
#endif
if (code == 0) {
SV *st;
EXTEND(sp, 1);
st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_TOKEN", (void *) t);
PUSHs(st);
if (pwexpires != -1)
sv_setiv(ST(7), (IV) pw);
XSRETURN(1);
}
else {
char buffer[256];
sprintf(buffer, "AFS::KTC_TOKEN: ");
KSETCODE(code, buffer);
safefree(t);
XSRETURN_UNDEF;
}
}
MODULE = AFS PACKAGE = AFS PREFIX = afs_
BOOT:
initialize_bz_error_table();
initialize_vols_error_table();
initialize_vl_error_table();
initialize_u_error_table();
initialize_pt_error_table();
initialize_ka_error_table();
initialize_acfg_error_table();
initialize_ktc_error_table();
initialize_rxk_error_table();
/* initialize_cmd_error_table(); */
/* initialize_budb_error_table(); */
/* initialize_butm_error_table(); */
/* initialize_butc_error_table(); */
void
afs__finalize()
CODE:
{
if (rx_initialized) {
rx_Finalize();
/* printf("AFS DEBUG rx_Finalize\n"); */
}
}
int32
afs_ascii2ptsaccess(access)
char * access
CODE:
{
int32 code, flags;
code = parse_pts_setfields(access, &flags);
SETCODE(code);
if (code != 0)
flags = 0;
RETVAL = flags;
}
OUTPUT:
RETVAL
void
afs_ptsaccess2ascii(flags)
int32 flags
CODE:
{
SETCODE(0);
ST(0) = sv_newmortal();
sv_setpv(ST(0), parse_flags_ptsaccess(flags));
}
void
afs_ka_ParseLoginName(login)
char * login
PPCODE:
{
int32 code;
char name[MAXKTCNAMELEN];
char inst[MAXKTCNAMELEN];
char cell[MAXKTCREALMLEN];
code = ka_ParseLoginName(login, name, inst, cell);
SETCODE(code);
if (code == 0) {
EXTEND(sp, 3);
PUSHs(sv_2mortal(newSVpv(name, strlen(name))));
PUSHs(sv_2mortal(newSVpv(inst, strlen(inst))));
PUSHs(sv_2mortal(newSVpv(cell, strlen(cell))));
}
}
void
afs_ka_StringToKey(str,cell)
KSETCODE(code, buffer);
safefree(key);
XSRETURN_UNDEF;
}
}
void
afs_ka_UserReadPassword(prompt,reason=0)
char * prompt
char * reason
PPCODE:
{
int32 code;
char buffer[1024];
char *r;
code = ka_UserReadPassword(prompt, buffer, sizeof(buffer) - 1, &r);
SETCODE(code);
if (reason)
sv_setpv(ST(1), r);
if (code == 0) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSVpv(buffer, strlen(buffer))));
}
}
void
afs_ka_GetAdminToken(p,key,lifetime,newt=1,reason=0)
AFS::KTC_PRINCIPAL p
AFS::KTC_EKEY key
int32 lifetime
int32 newt
char * reason
PPCODE:
{
int32 code;
struct ktc_token *t;
char *message;
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
code = ka_GetAdminToken(p->name, p->instance, p->cell, key, lifetime, t, newt);
SETCODE(code);
if (code == 0) {
SV *st;
EXTEND(sp, 1);
st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_TOKEN", (void *) t);
PUSHs(st);
}
else {
safefree(t);
switch (code) {
case KABADREQUEST:
message = "password was incorrect";
break;
case KAUBIKCALL:
message = "Authentication Server was unavailable";
break;
default:
message = (char *) error_message(code);
}
sv_setpv(ST(4), message);
}
}
void
afs_ka_GetAuthToken(p,key,lifetime,pwexpires=-1)
AFS::KTC_PRINCIPAL p
AFS::KTC_EKEY key
int32 lifetime
int32 pwexpires
PPCODE:
{
int32 code;
int32 pw;
code = ka_GetAuthToken(p->name, p->instance, p->cell, key, lifetime, &pw);
SETCODE(code);
if (code == 0) {
if (pwexpires != -1)
sv_setiv(ST(3), (IV) pw);
}
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSViv(code == 0)));
}
void
afs_ka_GetServerToken(p,lifetime,newt=1)
AFS::KTC_PRINCIPAL p
int32 lifetime
int32 newt
PPCODE:
{
int32 code;
struct ktc_token *t;
#if defined(AFS_3_4)
#else
int32 dosetpag;
#endif
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
#if defined(AFS_3_4)
code = ka_GetServerToken(p->name, p->instance, p->cell, lifetime, t, newt);
#else
dosetpag = 0;
code = ka_GetServerToken(p->name, p->instance, p->cell, lifetime, t, newt, dosetpag);
#endif
SETCODE(code);
if (code == 0) {
SV *st;
EXTEND(sp, 1);
st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_TOKEN", (void *) t);
PUSHs(st);
}
PUSHs(sc);
}
else {
safefree(c);
safefree(t);
}
}
void
afs_ktc_FromString(s)
SV *s
PPCODE:
{
SV *sv;
STRLEN len;
char *str;
struct ktc_token *t;
str = SvPV(s, len);
EXTEND(sp, 1);
if (len == sizeof(struct ktc_token)) {
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
memcpy((void *) t, (void *) str, sizeof(struct ktc_token));
sv = sv_newmortal();
sv_setref_pv(sv, "AFS::KTC_TOKEN", (void *) t);
PUSHs(sv);
}
else {
PUSHs(&PL_sv_undef);
}
}
void
afs_ktc_SetToken(server,token,client,flags=0)
AFS::KTC_PRINCIPAL server
AFS::KTC_TOKEN token
AFS::KTC_PRINCIPAL client
int32 flags
PPCODE:
{
int32 code;
code = ktc_SetToken(server, token, client, flags);
SETCODE(code);
ST(0) = sv_2mortal(newSViv(code == 0));
XSRETURN(1);
}
void
afs_ktc_ForgetAllTokens()
PPCODE:
{
int32 code;
code = ktc_ForgetAllTokens();
SETCODE(code);
ST(0) = sv_2mortal(newSViv(code == 0));
XSRETURN(1);
}
void
afs_error_message(code)
int32 code
PPCODE:
{
ST(0) = sv_newmortal();
sv_setpv(ST(0), (char *) error_message(code));
XSRETURN(1);
}
/* this function is generated automatically by constant_gen */
/* You didn't think I would type in this crap did you? */
/* thats what perl is for :-) */
#if defined(AFS_3_4)
void
constant(name, arg=0)
char * name
int arg
PPCODE:
{
ST(0) = sv_newmortal();
errno = EINVAL;
switch (name[0]) {
case 'A':
switch (name[1]) {
case 'F':
switch (name[2]) {
case 'S':
if (strEQ(name,"AFSCONF_FAILURE")) sv_setiv(ST(0),AFSCONF_FAILURE);
else if (strEQ(name,"AFSCONF_FULL")) sv_setiv(ST(0),AFSCONF_FULL);
else if (strEQ(name,"AFSCONF_NOCELL")) sv_setiv(ST(0),AFSCONF_NOCELL);
else if (strEQ(name,"AFSCONF_NODB")) sv_setiv(ST(0),AFSCONF_NODB);
else if (strEQ(name,"AFSCONF_NOTFOUND")) sv_setiv(ST(0),AFSCONF_NOTFOUND);
else if (strEQ(name,"AFSCONF_SYNTAX")) sv_setiv(ST(0),AFSCONF_SYNTAX);
else if (strEQ(name,"AFSCONF_UNKNOWN")) sv_setiv(ST(0),AFSCONF_UNKNOWN);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'N':
switch (name[2]) {
case 'O':
if (strEQ(name,"ANONYMOUSID")) sv_setiv(ST(0),ANONYMOUSID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'Y':
if (strEQ(name,"ANYUSERID")) sv_setiv(ST(0),ANYUSERID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'U':
switch (name[2]) {
case 'T':
if (strEQ(name,"AUTHUSERID")) sv_setiv(ST(0),AUTHUSERID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
else if (strEQ(name,"VIOCENGROUP")) sv_setiv(ST(0),VIOCENGROUP);
else if (strEQ(name,"VIOCFLUSH")) sv_setiv(ST(0),VIOCFLUSH);
else if (strEQ(name,"VIOCFLUSHCB")) sv_setiv(ST(0),VIOCFLUSHCB);
else if (strEQ(name,"VIOCGETAL")) sv_setiv(ST(0),VIOCGETAL);
else if (strEQ(name,"VIOCGETCACHEPARMS")) sv_setiv(ST(0),VIOCGETCACHEPARMS);
else if (strEQ(name,"VIOCGETCELL")) sv_setiv(ST(0),VIOCGETCELL);
else if (strEQ(name,"VIOCGETFID")) sv_setiv(ST(0),VIOCGETFID);
else if (strEQ(name,"VIOCGETTIME")) sv_setiv(ST(0),VIOCGETTIME);
else if (strEQ(name,"VIOCGETTOK")) sv_setiv(ST(0),VIOCGETTOK);
else if (strEQ(name,"VIOCGETVCXSTATUS")) sv_setiv(ST(0),VIOCGETVCXSTATUS);
else if (strEQ(name,"VIOCGETVOLSTAT")) sv_setiv(ST(0),VIOCGETVOLSTAT);
else if (strEQ(name,"VIOCLISTGROUPS")) sv_setiv(ST(0),VIOCLISTGROUPS);
else if (strEQ(name,"VIOCNEWCELL")) sv_setiv(ST(0),VIOCNEWCELL);
else if (strEQ(name,"VIOCNOP")) sv_setiv(ST(0),VIOCNOP);
else if (strEQ(name,"VIOCPREFETCH")) sv_setiv(ST(0),VIOCPREFETCH);
else if (strEQ(name,"VIOCSETAL")) sv_setiv(ST(0),VIOCSETAL);
else if (strEQ(name,"VIOCSETCACHESIZE")) sv_setiv(ST(0),VIOCSETCACHESIZE);
else if (strEQ(name,"VIOCSETTOK")) sv_setiv(ST(0),VIOCSETTOK);
else if (strEQ(name,"VIOCSETVOLSTAT")) sv_setiv(ST(0),VIOCSETVOLSTAT);
else if (strEQ(name,"VIOCSTAT")) sv_setiv(ST(0),VIOCSTAT);
else if (strEQ(name,"VIOCUNLOG")) sv_setiv(ST(0),VIOCUNLOG);
else if (strEQ(name,"VIOCUNPAG")) sv_setiv(ST(0),VIOCUNPAG);
else if (strEQ(name,"VIOCWAITFOREVER")) sv_setiv(ST(0),VIOCWAITFOREVER);
else if (strEQ(name,"VIOCWHEREIS")) sv_setiv(ST(0),VIOCWHEREIS);
else if (strEQ(name,"VIOC_AFS_DELETE_MT_PT")) sv_setiv(ST(0),VIOC_AFS_DELETE_MT_PT);
else if (strEQ(name,"VIOC_AFS_MARINER_HOST")) sv_setiv(ST(0),VIOC_AFS_MARINER_HOST);
else if (strEQ(name,"VIOC_AFS_STAT_MT_PT")) sv_setiv(ST(0),VIOC_AFS_STAT_MT_PT);
else if (strEQ(name,"VIOC_AFS_SYSNAME")) sv_setiv(ST(0),VIOC_AFS_SYSNAME);
else if (strEQ(name,"VIOC_EXPORTAFS")) sv_setiv(ST(0),VIOC_EXPORTAFS);
else if (strEQ(name,"VIOC_FILE_CELL_NAME")) sv_setiv(ST(0),VIOC_FILE_CELL_NAME);
else if (strEQ(name,"VIOC_FLUSHVOLUME")) sv_setiv(ST(0),VIOC_FLUSHVOLUME);
else if (strEQ(name,"VIOC_GAG")) sv_setiv(ST(0),VIOC_GAG);
else if (strEQ(name,"VIOC_GETCELLSTATUS")) sv_setiv(ST(0),VIOC_GETCELLSTATUS);
else if (strEQ(name,"VIOC_GETSPREFS")) sv_setiv(ST(0),VIOC_GETSPREFS);
else if (strEQ(name,"VIOC_GET_PRIMARY_CELL")) sv_setiv(ST(0),VIOC_GET_PRIMARY_CELL);
else if (strEQ(name,"VIOC_GET_WS_CELL")) sv_setiv(ST(0),VIOC_GET_WS_CELL);
else if (strEQ(name,"VIOC_SETCELLSTATUS")) sv_setiv(ST(0),VIOC_SETCELLSTATUS);
else if (strEQ(name,"VIOC_SETSPREFS")) sv_setiv(ST(0),VIOC_SETSPREFS);
else if (strEQ(name,"VIOC_TWIDDLE")) sv_setiv(ST(0),VIOC_TWIDDLE);
else if (strEQ(name,"VIOC_VENUSLOG")) sv_setiv(ST(0),VIOC_VENUSLOG);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
errno = 0;
XSRETURN(1);
return;
}
#else
void
constant(name, arg=0)
char * name
int arg
PPCODE:
{
ST(0) = sv_newmortal();
errno = EINVAL;
switch (name[0]) {
case 'A':
switch (name[1]) {
case 'F':
switch (name[2]) {
case 'S':
if (strEQ(name,"AFSCONF_FAILURE")) sv_setiv(ST(0),AFSCONF_FAILURE);
else if (strEQ(name,"AFSCONF_FULL")) sv_setiv(ST(0),AFSCONF_FULL);
else if (strEQ(name,"AFSCONF_NOCELL")) sv_setiv(ST(0),AFSCONF_NOCELL);
else if (strEQ(name,"AFSCONF_NODB")) sv_setiv(ST(0),AFSCONF_NODB);
else if (strEQ(name,"AFSCONF_NOTFOUND")) sv_setiv(ST(0),AFSCONF_NOTFOUND);
else if (strEQ(name,"AFSCONF_SYNTAX")) sv_setiv(ST(0),AFSCONF_SYNTAX);
else if (strEQ(name,"AFSCONF_UNKNOWN")) sv_setiv(ST(0),AFSCONF_UNKNOWN);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'N':
switch (name[2]) {
case 'O':
if (strEQ(name,"ANONYMOUSID")) sv_setiv(ST(0),ANONYMOUSID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'Y':
if (strEQ(name,"ANYUSERID")) sv_setiv(ST(0),ANYUSERID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
case 'U':
switch (name[2]) {
case 'T':
if (strEQ(name,"AUTHUSERID")) sv_setiv(ST(0),AUTHUSERID);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
else if (strEQ(name,"VIOCENGROUP")) sv_setiv(ST(0),VIOCENGROUP);
else if (strEQ(name,"VIOCFLUSH")) sv_setiv(ST(0),VIOCFLUSH);
else if (strEQ(name,"VIOCFLUSHCB")) sv_setiv(ST(0),VIOCFLUSHCB);
else if (strEQ(name,"VIOCGETAL")) sv_setiv(ST(0),VIOCGETAL);
else if (strEQ(name,"VIOCGETCACHEPARMS")) sv_setiv(ST(0),VIOCGETCACHEPARMS);
else if (strEQ(name,"VIOCGETCELL")) sv_setiv(ST(0),VIOCGETCELL);
else if (strEQ(name,"VIOCGETFID")) sv_setiv(ST(0),VIOCGETFID);
else if (strEQ(name,"VIOCGETTIME")) sv_setiv(ST(0),VIOCGETTIME);
else if (strEQ(name,"VIOCGETTOK")) sv_setiv(ST(0),VIOCGETTOK);
else if (strEQ(name,"VIOCGETVCXSTATUS")) sv_setiv(ST(0),VIOCGETVCXSTATUS);
else if (strEQ(name,"VIOCGETVOLSTAT")) sv_setiv(ST(0),VIOCGETVOLSTAT);
else if (strEQ(name,"VIOCLISTGROUPS")) sv_setiv(ST(0),VIOCLISTGROUPS);
else if (strEQ(name,"VIOCNEWCELL")) sv_setiv(ST(0),VIOCNEWCELL);
else if (strEQ(name,"VIOCNOP")) sv_setiv(ST(0),VIOCNOP);
else if (strEQ(name,"VIOCPREFETCH")) sv_setiv(ST(0),VIOCPREFETCH);
else if (strEQ(name,"VIOCSETAL")) sv_setiv(ST(0),VIOCSETAL);
else if (strEQ(name,"VIOCSETCACHESIZE")) sv_setiv(ST(0),VIOCSETCACHESIZE);
else if (strEQ(name,"VIOCSETTOK")) sv_setiv(ST(0),VIOCSETTOK);
else if (strEQ(name,"VIOCSETVOLSTAT")) sv_setiv(ST(0),VIOCSETVOLSTAT);
else if (strEQ(name,"VIOCSTAT")) sv_setiv(ST(0),VIOCSTAT);
else if (strEQ(name,"VIOCUNLOG")) sv_setiv(ST(0),VIOCUNLOG);
else if (strEQ(name,"VIOCUNPAG")) sv_setiv(ST(0),VIOCUNPAG);
else if (strEQ(name,"VIOCWAITFOREVER")) sv_setiv(ST(0),VIOCWAITFOREVER);
else if (strEQ(name,"VIOCWHEREIS")) sv_setiv(ST(0),VIOCWHEREIS);
else if (strEQ(name,"VIOC_AFS_DELETE_MT_PT")) sv_setiv(ST(0),VIOC_AFS_DELETE_MT_PT);
else if (strEQ(name,"VIOC_AFS_MARINER_HOST")) sv_setiv(ST(0),VIOC_AFS_MARINER_HOST);
else if (strEQ(name,"VIOC_AFS_STAT_MT_PT")) sv_setiv(ST(0),VIOC_AFS_STAT_MT_PT);
else if (strEQ(name,"VIOC_AFS_SYSNAME")) sv_setiv(ST(0),VIOC_AFS_SYSNAME);
else if (strEQ(name,"VIOC_EXPORTAFS")) sv_setiv(ST(0),VIOC_EXPORTAFS);
else if (strEQ(name,"VIOC_FILE_CELL_NAME")) sv_setiv(ST(0),VIOC_FILE_CELL_NAME);
else if (strEQ(name,"VIOC_FLUSHVOLUME")) sv_setiv(ST(0),VIOC_FLUSHVOLUME);
else if (strEQ(name,"VIOC_GAG")) sv_setiv(ST(0),VIOC_GAG);
else if (strEQ(name,"VIOC_GETCELLSTATUS")) sv_setiv(ST(0),VIOC_GETCELLSTATUS);
else if (strEQ(name,"VIOC_GETSPREFS")) sv_setiv(ST(0),VIOC_GETSPREFS);
else if (strEQ(name,"VIOC_GET_PRIMARY_CELL")) sv_setiv(ST(0),VIOC_GET_PRIMARY_CELL);
else if (strEQ(name,"VIOC_GET_WS_CELL")) sv_setiv(ST(0),VIOC_GET_WS_CELL);
else if (strEQ(name,"VIOC_SETCELLSTATUS")) sv_setiv(ST(0),VIOC_SETCELLSTATUS);
else if (strEQ(name,"VIOC_SETSPREFS")) sv_setiv(ST(0),VIOC_SETSPREFS);
else if (strEQ(name,"VIOC_TWIDDLE")) sv_setiv(ST(0),VIOC_TWIDDLE);
else if (strEQ(name,"VIOC_VENUSLOG")) sv_setiv(ST(0),VIOC_VENUSLOG);
else {
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
break;
default:
ST(0) = ST(1) = &PL_sv_undef;
return;
}
errno = 0;
XSRETURN(1);
return;
}
#endif
( run in 1.616 second using v1.01-cache-2.11-cpan-39bf76dae61 )