* Private: represents a queued dump/restore item.
*/
struct bc_dumpTask {
- int (*callProc) ();
+ int (*callProc) (afs_int32);
struct bc_config *config;
struct bc_volumeDump *volumes;
char *dumpName; /*Dump name we're doing */
#include <afs/bubasics.h>
#include <lock.h>
#include <afs/tcdata.h>
+#include <afs/cmd.h>
#include "bc.h"
#include "error_macros.h"
+#include "bucoord_prototypes.h"
#define SET_FLAG(set) \
lock_Status(); \
* get next item for status interrogation, if any.
*/
static statusP
-nextItem(linkPtr)
- statusP linkPtr;
+nextItem(statusP linkPtr)
{
dlqlinkP ptr;
cmdDispatch(void *unused)
{
#define MAXV 100
- char **targv[MAXV]; /*Ptr to parsed argv stuff */
+ char *targv[MAXV]; /*Ptr to parsed argv stuff */
afs_int32 targc; /*Num parsed arguments */
afs_int32 code;
char *internalCmdLine;
void *
statusWatcher(void *unused)
{
- struct rx_connection *tconn = (struct rc_connection *)0;
+ struct rx_connection *tconn = NULL;
statusP curPollPtr = 0;
struct tciStatusS statusPtr;
while (1) { /*w */
if (tconn)
rx_DestroyConnection(tconn);
- tconn = (struct rc_connection *)0;
+ tconn = NULL;
lock_Status();
curPollPtr = nextItem(curPollPtr);
*/
afs_int32
-bc_jobNumber()
+bc_jobNumber(void)
{
afs_int32 retval = 0;
dlqlinkP ptr;
* Return the task's flags when it's done. If the job
* had been cleaned up, then just return 0.
*/
-waitForTask(taskId)
- afs_uint32 taskId;
+int
+waitForTask(afs_uint32 taskId)
{
statusP ptr;
- afs_int32 done = 0, rcode, t;
+ afs_int32 done = 0, rcode = 0, t;
t = (TASK_DONE | ABORT_DONE | TASK_ERROR);
while (!done) {
/* bc_status.c */
extern void *statusWatcher(void *);
+extern afs_int32 bc_jobNumber(void);
+extern int waitForTask(afs_uint32 taskId);
+/* command.c */
+extern char *bc_CopyString(char *astring);
+extern afs_int32 getPortOffset(char *port);
+extern afs_int32 bc_SafeATOI(char *anum);
+extern int bc_WaitForNoJobs(void);
+
+struct cmd_syndesc;
+extern int bc_DumpCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_VolRestoreCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_DiskRestoreCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_QuitCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_VolsetRestoreCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_AddHostCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_DeleteHostCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_ListHostsCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_JobsCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_KillCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_ListVolSetCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_ListDumpScheduleCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_AddVolSetCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_GetTapeStatusCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_DeleteVolSetCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_AddVolEntryCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_DeleteVolEntryCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_AddDumpCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_DeleteDumpCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_LabelTapeCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_ReadLabelCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_ScanDumpsCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_dblookupCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_SetExpCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_saveDbCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_restoreDbCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_dumpInfoCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_dbVerifyCmd(struct cmd_syndesc *as, void *arock);
+extern int bc_deleteDumpCmd(struct cmd_syndesc *as, void *arock);
+
+
+
+
+
+
+
+
+
+/* config.c */
+extern int bc_AddTapeHost(struct bc_config *aconfig, char *aname,
+ afs_int32 aport);
+extern int bc_DeleteTapeHost(struct bc_config *aconfig, char *aname,
+ afs_int32 aport);
+
+/* dlq.c */
+extern int dlqEmpty(dlqlinkP headptr );
+extern int dlqInit(dlqlinkP headptr );
+extern void dlqUnlink(dlqlinkP );
+extern int dlqLinkb(dlqlinkP headptr, dlqlinkP entryptr);
+
+/* dsstub.c */
+extern char *tailCompPtr(char *pathNamePtr);
+
+/* dsvs.c */
+extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *aconfig,
+ char *aname);
+extern void FreeVolumeSet(struct bc_volumeSet *);
+extern int bc_AddVolumeItem(struct bc_config *aconfig, char *avolName,
+ char *ahost, char *apart, char *avol);
+extern int bc_CreateVolumeSet(struct bc_config *aconfig, char *avolName,
+ afs_int32 aflags);
+extern int bc_DeleteVolumeItem(struct bc_config *aconfig, char *avolName,
+ afs_int32 anumber);
+extern int bc_DeleteVolumeSet(struct bc_config *aconfig, char *avolName,
+ afs_int32 *flags);
+extern int bc_ParseHost(char *aname, struct sockaddr_in *asockaddr);
+extern afs_int32 bc_GetPartitionID(char *aname, afs_int32 *aval);
+extern int bc_CreateDumpSchedule(struct bc_config *aconfig, char *adumpName,
+ afs_int32 expDate, afs_int32 expType);
+extern int bc_DeleteDumpSchedule(struct bc_config *aconfig, char *adumpName);
+extern int FindDump(struct bc_config *aconfig, char *nodeString,
+ struct bc_dumpSchedule **parentptr,
+ struct bc_dumpSchedule **nodeptr);
+extern int bc_ProcessDumpSchedule(struct bc_config *aconfig);
+extern struct bc_dumpSchedule * bc_FindDumpSchedule(struct bc_config *aconfig,
+ char *aname);
+
+
+/* dump.c */
+extern int CheckTCVersion(struct rx_connection *tconn);
+extern int ConnectButc(struct bc_config *config, afs_int32 port,
+ struct rx_connection **tconn);
+extern int bc_StartDmpRst(struct bc_config *aconfig, char *adname,
+ char *avname, struct bc_volumeDump *avolsToDump,
+ struct sockaddr_in *adestServer,
+ afs_int32 adestPartition, afs_int32 afromDate,
+ char *anewExt, int aoldFlag, afs_int32 aparent,
+ afs_int32 alevel, int (*aproc) (int),
+ afs_int32 *ports, afs_int32 portCount,
+ struct bc_dumpSchedule *dsptr, int append,
+ int dontExecute);
+extern int bc_Dumper(int);
+extern int bc_LabelTape(char *afsname, char *pname, afs_int32 size,
+ struct bc_config *config, afs_int32 port);
+extern int bc_ReadLabel(struct bc_config *config, afs_int32 port);
+extern int bc_ScanDumps(struct bc_config *config, afs_int32 dbAddFlag,
+ afs_int32 port);
+
+
+
+
+/* dump_sched.c */
+extern afs_int32 bc_UpdateDumpSchedule(void);
+extern int bc_SaveDumpSchedule(void);
+
+/* expire.c */
+struct cmd_parmdesc;
+extern afs_int32 bc_ParseExpiration(struct cmd_parmdesc *paramPtr,
+ afs_int32 *expType, afs_int32 *expDate);
+/* main.c */
+extern afs_int32 doDispatch(afs_int32, char *[], afs_int32);
+extern void bc_HandleMisc(afs_int32 code);
+
+/* regex.c */
+extern char *re_comp(const char *sp);
+extern int re_exec(const char *p1);
+
+/* restore.c */
+extern int BackupName(char *);
+extern int bc_Restorer(afs_int32);
+
+/* status.c */
+extern void initStatus(void);
+extern void lock_Status(void);
+extern void unlock_Status(void);
+extern void lock_cmdLine(void);
+extern void unlock_cmdLine(void);
+extern void clearStatus(afs_uint32, afs_uint32);
+extern statusP createStatusNode(void);
+extern void deleteStatusNode(statusP ptr);
+extern statusP findStatus(afs_uint32);
+
+/* tape_hosts.c */
+extern afs_int32 bc_UpdateHosts(void);
+extern int bc_SaveHosts(void);
+
+/* ubik_db_if.c */
+extern int bc_LockText(udbClientTextP ctPtr);
+extern int bc_UnlockText(udbClientTextP ctPtr);
+extern int bcdb_SaveTextFile(udbClientTextP ctPtr);
+extern afs_int32 filesize(FILE *stream);
+extern int bc_CheckTextVersion(udbClientTextP ctPtr);
+extern int bc_openTextFile(udbClientTextP ctPtr, char *tmpFileName);
+extern int bcdb_GetTextFile(register udbClientTextP ctPtr);
+extern int bcdb_FindDumpByID(afs_int32 dumpID, struct budb_dumpEntry *deptr);
+extern afs_int32 bcdb_FindVolumes(afs_int32 dumpID, char *volumeName,
+ struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next,
+ afs_int32 maxa, afs_int32 *nEntries);
+extern int bcdb_FindDump(char *volumeName, afs_int32 beforeDate,
+ struct budb_dumpEntry *deptr);
+extern afs_int32 bcdb_FindLastVolClone(char *volSetName, char *dumpName,
+ char *volName, afs_int32 *clonetime);
+extern int bcdb_FindLatestDump(char *volSetName, char *dumpPath,
+ struct budb_dumpEntry *deptr);
+extern afs_int32 bcdb_FindClone(afs_int32 dumpID, char *volName,
+ afs_int32 *clonetime);
+extern afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *);
+extern afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *,
+ afs_int32 );
+extern afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *) ;
+extern afs_int32 bcdb_deleteDump(afs_int32 dumpID, afs_int32 fromTime,
+ afs_int32 toTime, budb_dumpsList *dumps);
+extern afs_int32 bcdb_listDumps (afs_int32 sflags, afs_int32 groupId,
+ afs_int32 fromTime, afs_int32 toTime,
+ budb_dumpsList *dumps, budb_dumpsList *flags);
+extern afs_int32 bcdb_DeleteVDP(char *, char *, afs_int32 );
+extern afs_int32 bcdb_FindClone(afs_int32, char *, afs_int32 *);
+extern afs_int32 bcdb_LookupVolume(char *volumeName,
+ struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next,
+ afs_int32 maxa, afs_int32 *nEntries);
+extern int bcdb_FindTape(afs_int32 dumpid, char *tapeName,
+ struct budb_tapeEntry *teptr);
+extern int bcdb_FindTapeSeq(afs_int32 dumpid, afs_int32 tapeSeq,
+ struct budb_tapeEntry *teptr);
+
+/* vol_sets.c */
+extern afs_int32 bc_UpdateVolumeSet(void);
+extern int bc_SaveVolumeSet(void);
+
+/* volstub.c */
+
+extern afs_int32 volImageTime(afs_int32 serv, afs_int32 part, afs_int32 volid,
+ afs_int32 voltype, afs_int32 *clDatePtr);
#endif
#include <afs/voldefs.h> /* PA */
#include <afs/vldbint.h> /* PA */
#include <afs/ktime.h> /* PA */
+#include <ubik.h>
#include <time.h>
-
#include <lock.h>
#include <afs/butc.h>
#include <afs/tcdata.h>
#include <afs/butx.h>
+#include <afs/vsutils_prototypes.h>
#include "bc.h"
#include "error_macros.h"
-
+#include "bucoord_prototypes.h"
+#include "regex.h"
extern struct bc_config *bc_globalConfig;
-extern struct bc_dumpSchedule *bc_FindDumpSchedule();
-extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cfg,
- char *name);
extern struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
extern struct ubik_client *cstruct;
-extern int bc_Dumper(); /* function to do dumps */
-extern int bc_Restorer(); /* function to do restores */
extern char *whoami;
extern struct ktc_token ttoken;
-extern char *tailCompPtr();
-extern statusP createStatusNode();
char *loadFile;
extern afs_int32 lastTaskCode;
#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.s_addr
+static int EvalVolumeSet1(struct bc_config *aconfig, struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient);
+
+static int EvalVolumeSet2(struct bc_config *aconfig, struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient);
+static int DBLookupByVolume(char *volumeName);
+
int
-bc_EvalVolumeSet(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- register struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
+bc_EvalVolumeSet(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
{ /*bc_EvalVolumeSet */
- int code;
+ int code = -1;
static afs_int32 use = 2;
if (use == 2) { /* Use EvalVolumeSet2() */
};
afs_int32
-getSPEntries(server, partition, serverlist, ss, ps)
- afs_uint32 server;
- afs_int32 partition;
- struct serversort **serverlist, **ss;
- struct partitionsort **ps;
+getSPEntries(afs_uint32 server, afs_int32 partition,
+ struct serversort **serverlist,
+ struct serversort **ss,
+ struct partitionsort **ps)
{
if (!(*ss) || ((*ss)->ipaddr != server)) {
*ps = 0;
}
afs_int32
-randSPEntries(serverlist, avols)
- struct serversort *serverlist;
- struct bc_volumeDump **avols;
+randSPEntries(struct serversort *serverlist,
+ struct bc_volumeDump **avols)
{
struct serversort *ss, **pss;
struct partitionsort *ps, **pps;
return 0;
}
-int
-EvalVolumeSet2(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
+static int
+EvalVolumeSet2(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
{ /*EvalVolumeSet2 */
struct bc_volumeEntry *tve;
struct bc_volumeDump *tavols;
struct bc_volumeDump *tvd;
afs_int32 code = 0, tcode;
afs_int32 count = 0;
- struct serversort *servers = 0, *lastserver = 0, *ss = 0;
+ struct serversort *servers = 0, *ss = 0;
struct partitionsort *ps = 0;
*avols = (struct bc_volumeDump *)0;
* None.
*-----------------------------------------------------------------------------
*/
-int
-EvalVolumeSet1(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
+static int
+EvalVolumeSet1(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
{ /*EvalVolumeSet1 */
afs_int32 code; /*Result of various calls */
char *errm;
* ptr to a string containing a representation of the date
*/
char *
-compactDateString(date_long, string, size)
- afs_int32 *date_long, size;
- char *string;
+compactDateString(afs_uint32 *date_long, char *string, afs_int32 size)
{
struct tm *ltime;
}
afs_int32
-bc_SafeATOI(anum)
- char *anum;
+bc_SafeATOI(char *anum)
{
afs_int32 total = 0;
* Return the size in KBytes.
*/
afs_int32
-bc_FloatATOI(anum)
- char *anum;
+bc_FloatATOI(char *anum)
{
float total = 0;
afs_int32 rtotal;
/* make a copy of a string so that it can be freed later */
char *
-bc_CopyString(astring)
- char *astring;
+bc_CopyString(char *astring)
{
afs_int32 tlen;
char *tp;
*/
char *
-concatParams(itemPtr)
- struct cmd_item *itemPtr;
+concatParams(struct cmd_item *itemPtr)
{
struct cmd_item *tempPtr;
afs_int32 length = 0;
*/
void
-printIfStatus(statusPtr)
- struct tciStatusS *statusPtr;
+printIfStatus(struct tciStatusS *statusPtr)
{
printf("Task %d: %s: ", statusPtr->taskId, statusPtr->taskName);
if (statusPtr->nKBytes)
- printf("%ld Kbytes transferred", statusPtr->nKBytes);
+ printf("%ld Kbytes transferred", (long unsigned int) statusPtr->nKBytes);
if (strlen(statusPtr->volumeName) != 0) {
if (statusPtr->nKBytes)
printf(", ");
}
afs_int32
-getPortOffset(port)
- char *port;
+getPortOffset(char *port)
{
afs_int32 portOffset;
/* bc_WaitForNoJobs
* wait for all jobs to terminate
*/
-bc_WaitForNoJobs()
+int
+bc_WaitForNoJobs(void)
{
- afs_int32 wcode = 0;
int i;
- int waitmsg = 1;
int usefulJobRunning = 1;
extern dlqlinkT statusHead;
if (statusPtr->dbDumpId)
printf(": DumpID %u", statusPtr->dbDumpId);
if (statusPtr->nKBytes)
- printf(", %ld Kbytes", statusPtr->nKBytes);
+ printf(", %ld Kbytes", (long int) statusPtr->nKBytes);
if (strlen(statusPtr->volumeName) != 0)
printf(", volume %s", statusPtr->volumeName);
statusP statusPtr;
extern dlqlinkT statusHead;
- extern statusP findStatus();
-
tp = as->parms[0].items->data;
if (strchr(tp, '.') == 0) {
afs_int32 *ports = NULL;
afs_int32 portCount = 0;
afs_int32 code = 0;
- afs_int32 portoffset = 0;
char *volsetName;
struct bc_volumeSet *volsetPtr; /* Ptr to list of generated volume info */
struct bc_volumeDump *volsToRestore = (struct bc_volumeDump *)0;
int
bc_DumpCmd(struct cmd_syndesc *as, void *arock)
{ /*bc_DumpCmd */
- static char rn[] = "bc_DumpCmd"; /*Routine name */
char *dumpPath = NULL;
char *vsName = NULL; /*Ptrs to various names */
struct bc_volumeSet *tvs = NULL; /*Ptr to list of generated volume info */
statusP statusPtr;
extern struct bc_dumpTask bc_dumpTasks[];
- extern afs_int32 bcdb_FindLastVolClone();
- extern afs_int32 volImageTime();
code = bc_UpdateDumpSchedule();
if (code) {
*/
afs_int32
-bc_ParseExpiration(paramPtr, expType, expDate)
- struct cmd_parmdesc *paramPtr;
- afs_int32 *expType;
- afs_int32 *expDate;
+bc_ParseExpiration(struct cmd_parmdesc *paramPtr, afs_int32 *expType,
+ afs_int32 *expDate)
{
struct cmd_item *itemPtr;
struct ktime_date kt;
/* deleteDump:
* Delete a dump. If port is >= 0, it means try to delete from XBSA server
*/
-deleteDump(dumpid, port, force)
- afs_uint32 dumpid; /* The dumpid to delete */
- afs_int32 port; /* port==-1 means don't go to butc */
- afs_int32 force;
+int
+deleteDump(afs_uint32 dumpid, /* The dumpid to delete */
+ afs_int32 port, /* port==-1 means don't go to butc */
+ afs_int32 force)
{
afs_int32 code = 0, tcode;
struct budb_dumpEntry dumpEntry;
* volumeName - volume to lookup
*/
-DBLookupByVolume(volumeName)
- char *volumeName;
+static int
+DBLookupByVolume(char *volumeName)
{
struct budb_dumpEntry dumpEntry;
struct budb_volumeEntry volumeEntry[DBL_MAX_VOLUMES];
*/
afs_int32
-dumpInfo(dumpid, detailFlag)
- afs_int32 dumpid;
- afs_int32 detailFlag;
+dumpInfo(afs_int32 dumpid, afs_int32 detailFlag)
{
struct budb_dumpEntry dumpEntry;
struct tapeLink *head = 0;
}
int
-compareDump(ptr1, ptr2)
- struct budb_dumpEntry *ptr1, *ptr2;
+compareDump(struct budb_dumpEntry *ptr1, struct budb_dumpEntry *ptr2)
{
if (ptr1->created < ptr2->created)
return (-1);
}
afs_int32
-printRecentDumps(ndumps)
- int ndumps;
+printRecentDumps(int ndumps)
{
afs_int32 code = 0;
afs_int32 nextindex, index = 0;
char ds[50];
extern struct udbHandleS udbHandle;
- extern compareDump();
do { /* while (nextindex != -1) */
/* initialize the dump list */
afs_int32 ndumps;
afs_int32 code = 0;
- afs_int32 dumpInfo();
-
if (as->parms[0].items) {
if (as->parms[1].items) {
afs_com_err(whoami, 0,
struct bc_config *bc_globalConfig;
-static
-TrimLine(abuffer, aport)
- afs_int32 *aport;
- register char *abuffer;
+#if 0
+static int
+TrimLine(char *abuffer, afs_int32 *aport)
{
register int tc;
char garb[100];
*aport = 0;
sscanf(abuffer, "%s %u", garb, aport);
- while (tc = *abuffer) {
+ while ((tc = *abuffer)) {
if (tc == ' ') {
*abuffer = 0;
return 0;
}
return 0;
}
+#endif
FILE *
-bc_open(aconfig, aname, aext, amode)
- register struct bc_config *aconfig;
- char *amode;
- char *aext;
- char *aname;
+bc_open(struct bc_config *aconfig, char *aname, char *aext, char *amode)
{
register FILE *tf;
char tpath[256];
return tf;
}
-bc_InitConfig(apath)
- char *apath;
+int
+bc_InitConfig(char *apath)
{
register struct bc_config *tb;
return 0;
}
-static
-HostAdd(alist, aname, aport)
- struct bc_hostEntry **alist;
- afs_int32 aport;
- char *aname;
+static int
+HostAdd(struct bc_hostEntry **alist, char *aname, afs_int32 aport)
{
register struct bc_hostEntry **tlast, *tentry;
struct hostent *th;
return 0;
}
-static
-HostDelete(alist, aname, aport)
- struct bc_hostEntry **alist;
- afs_int32 aport;
- char *aname;
+static int
+HostDelete(struct bc_hostEntry **alist, char *aname, afs_int32 aport)
{
register struct bc_hostEntry **tlast, *tentry;
return 0;
}
-bc_AddTapeHost(aconfig, aname, aport)
- struct bc_config *aconfig;
- afs_int32 aport;
- char *aname;
+int
+bc_AddTapeHost(struct bc_config *aconfig, char *aname, afs_int32 aport)
{
register afs_int32 code;
return code;
}
-bc_DeleteTapeHost(aconfig, aname, aport)
- struct bc_config *aconfig;
- afs_int32 aport;
- char *aname;
+int
+bc_DeleteTapeHost(struct bc_config *aconfig, char *aname, afs_int32 aport)
{
register afs_int32 code;
FILE * OpenTape(char * , char * );
static afs_int32 ScanForChildren(afs_int32 );
static afs_int32 DeleteDump(afs_int32 );
-static afs_int32 DeleteTape(char * );
char * tailCompPtr(char *);
afs_int32 ScanDumpHdr(register FILE *, char *, char *, afs_int32 *, afs_int32 *,
afs_int32 *, afs_int32 *);
-static afs_int32 ScanTapeHdr(register FILE *, afs_int32 *, afs_int32 *, afs_int32 *);
afs_int32 ScanTapeVolume(FILE *, char *, afs_int32 *, char *, afs_int32 *, afs_int32 *,
afs_int32 *, afs_int32 *);
afs_int32 ScanVolClone(FILE *, char *, afs_int32 *);
-static int SeekDump(register FILE *afile, afs_int32 apos);
/* basic format of a tape file is a file, whose name is "T<tapename>.db", and
* Note that dumpEndTime is stored and returned in the dump creation time field.
*/
-static afs_int32 DeleteDump();
-afs_int32 ScanDumpHdr();
-
/* return the tape file name corresponding to a particular tape */
static char * TapeName(register char *atapeName)
return -1;
for (tde = readdir(tdir); tde; tde = readdir(tdir)) {
- code = sscanf(tde->d_name, "D%ld.db", &dumpID);
+ code = sscanf(tde->d_name, "D%ld.db", (long int *) &dumpID);
if (code != 1)
continue;
return code;
}
+#if 0
static afs_int32 DeleteTape(char * atapeName)
{
register char *tp;
code = unlink(tp);
return code;
}
+#endif
/* tailCompPtr
* name is a pathname style name, determine trailing name and return
* pointer to it
*/
-char * tailCompPtr(char *pathNamePtr)
+char *
+tailCompPtr(char *pathNamePtr)
{
char *ptr;
ptr = strrchr(pathNamePtr, '/');
return -1;
code =
sscanf(tbuffer, "%d %d %s %s %ld %ld %ld %ld", &dbmagic, &dbversion,
- aname, dumpName, aparent, aincTime, acreateTime, alevel);
+ aname, dumpName, (long int *) aparent, (long int *) aincTime,
+ (long int *) acreateTime, (long int *) alevel);
if (code != 8)
return -1;
return 0;
}
+#if 0
/* scan a tape header out of a tape file, leaving the file ptr positioned just past the header */
static afs_int32 ScanTapeHdr(register FILE *afile, afs_int32 *adumpID, afs_int32 *aseq, afs_int32 *adamage)
{
tp = fgets(tbuffer, sizeof(tbuffer), afile);
if (!tp)
return -1;
- code = sscanf(tbuffer, "%ld %ld %ld", adumpID, aseq, adamage);
+ code = sscanf(tbuffer, "%ld %ld %ld", (long int *)adumpID,
+ (long int *)aseq, (long int *)adamage);
if (code != 3)
return -1;
return 0;
}
+#endif
/* ScanTapeVolume
* scan a tape volume record from a dump file, leaving the file ptr
return 1; /* eof */
}
code =
- sscanf(tbuffer, "%s %ld %s %ld %ld %ld %ld", avolName, avolID,
- atapeName, apos, aseq, alastp, cloneTime);
+ sscanf(tbuffer, "%s %ld %s %ld %ld %ld %ld", avolName,
+ (long int *) avolID, atapeName, (long int *)apos,
+ (long int *) aseq, (long int *) alastp,
+ (long int *) cloneTime);
if (code != 7)
return -1; /* bad input line */
return 0;
return (-1);
}
+#if 0
/* seek a dump file (after a header scan has been done) to position apos */
static int SeekDump(register FILE *afile, afs_int32 apos)
{
}
return 0;
}
+#endif
#include <afs/bubasics.h>
#include "bc.h"
-
-static char db_dsvs = 0; /*Assume debugging output turned off */
-static char mn[] = "dsvs"; /*Module name */
-
+#include "bucoord_prototypes.h"
+
struct ubik_client *cstructp; /*Ptr to Ubik client structure */
-extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cf,
- char *name);
-
-static FreeVolumeEntryList();
-static FreeVolumeEntry();
+static int FreeVolumeEntryList(struct bc_volumeEntry *aentry);
+static int FreeVolumeEntry(struct bc_volumeEntry *aentry);
/* Code to maintain dump schedule and volume set abstractions.
* A volume set looks like this:
/* get partition id from a name */
afs_int32
-bc_GetPartitionID(aname, aval)
- afs_int32 *aval;
- char *aname;
+bc_GetPartitionID(char *aname, afs_int32 *aval)
{
/*bc_GetPartitionID */
*/
int
-bc_ParseHost(aname, asockaddr)
- char *aname;
- struct sockaddr_in *asockaddr;
+bc_ParseHost(char *aname, struct sockaddr_in *asockaddr)
{ /*bc_ParseHost */
return -2; /* not found */
}
-bc_AddVolumeItem(aconfig, avolName, ahost, apart, avol)
- struct bc_config *aconfig;
- char *avolName;
- char *ahost, *apart, *avol;
+int
+bc_AddVolumeItem(struct bc_config *aconfig, char *avolName, char *ahost,
+ char *apart, char *avol)
{
struct bc_volumeSet *tset;
register struct bc_volumeEntry **tlast, *tentry;
* expType - absolute or relative
*/
-bc_CreateDumpSchedule(aconfig, adumpName, expDate, expType)
- struct bc_config *aconfig;
- char *adumpName;
- afs_int32 expDate;
- afs_int32 expType;
+int
+bc_CreateDumpSchedule(struct bc_config *aconfig, char *adumpName,
+ afs_int32 expDate, afs_int32 expType)
{
register struct bc_dumpSchedule *tdump;
struct bc_dumpSchedule *parent, *node;
* list of dumps. Note that this leaves the sibling pointers damaged (pointing
* to strange places), so we must call bc_ProcessDumpSchedule when we're done.
*/
-
-bc_DeleteDumpScheduleAddr(aconfig, adumpAddr)
- struct bc_config *aconfig;
- struct bc_dumpSchedule *adumpAddr;
+int
+bc_DeleteDumpScheduleAddr(struct bc_config *aconfig,
+ struct bc_dumpSchedule *adumpAddr)
{
register struct bc_dumpSchedule **tlast, *tdump;
register struct bc_dumpSchedule *tnext;
*/
struct bc_dumpSchedule *
-bc_FindDumpSchedule(aconfig, aname)
- char *aname;
- struct bc_config *aconfig;
+bc_FindDumpSchedule(struct bc_config *aconfig, char *aname)
{
register struct bc_dumpSchedule *tds;
for (tds = aconfig->dsched; tds; tds = tds->next) {
* Delete dump node adumpName from the dump schedule
*/
-bc_DeleteDumpSchedule(aconfig, adumpName)
- struct bc_config *aconfig;
- char *adumpName;
+int
+bc_DeleteDumpSchedule(struct bc_config *aconfig, char *adumpName)
{
register struct bc_dumpSchedule *tdump;
* of dump schedule nodes. It probably will never matter
*/
-bc_ProcessDumpSchedule(aconfig)
- register struct bc_config *aconfig;
+int
+bc_ProcessDumpSchedule(struct bc_config *aconfig)
{
register struct bc_dumpSchedule *tds;
struct bc_dumpSchedule *parentptr, *nodeptr;
*/
int
-FindDump(aconfig, nodeString, parentptr, nodeptr)
- struct bc_config *aconfig;
- char *nodeString;
- struct bc_dumpSchedule **parentptr;
- struct bc_dumpSchedule **nodeptr;
+FindDump(struct bc_config *aconfig, char *nodeString,
+ struct bc_dumpSchedule **parentptr,
+ struct bc_dumpSchedule **nodeptr)
{
struct bc_dumpSchedule *dsptr;
char *separator;
#include "bc.h"
#include "error_macros.h"
+#include "bucoord_prototypes.h"
struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
-extern char *bc_CopyString();
-extern void bc_HandleMisc();
extern char *whoami;
-extern char *tailCompPtr();
-extern statusP createStatusNode();
-extern afs_int32 bc_jobNumber();
extern afs_int32 lastTaskCode;
* aindex - index into dumpTask array, contains all the information
* relevant to the dump
*/
-bc_Dumper(aindex)
+int
+bc_Dumper(int aindex)
{
struct rx_connection *tconn;
register struct bc_volumeDump *tde;
*/
void
-freeDumpTaskVolumeList(vdptr)
- struct bc_volumeDump *vdptr;
+freeDumpTaskVolumeList(struct bc_volumeDump *vdptr)
{
struct bc_volumeDump *nextVdPtr;
* bc_Restorer for doing restores
*/
-bc_StartDmpRst(aconfig, adname, avname, avolsToDump, adestServer,
- adestPartition, afromDate, anewExt, aoldFlag, aparent, alevel,
- aproc, ports, portCount, dsptr, append, dontExecute)
- struct bc_config *aconfig;
- char *adname;
- char *avname;
- struct bc_volumeDump *avolsToDump;
- struct sockaddr_in *adestServer;
- afs_int32 adestPartition;
- afs_int32 afromDate;
- char *anewExt;
- int aoldFlag;
- afs_int32 aparent, alevel;
- int (*aproc) ();
- afs_int32 *ports;
- afs_int32 portCount;
- struct bc_dumpSchedule *dsptr;
- int append, dontExecute;
+int
+bc_StartDmpRst(struct bc_config *aconfig, char *adname, char *avname,
+ struct bc_volumeDump *avolsToDump,
+ struct sockaddr_in *adestServer,
+ afs_int32 adestPartition, afs_int32 afromDate, char *anewExt,
+ int aoldFlag, afs_int32 aparent, afs_int32 alevel,
+ int (*aproc) (int), afs_int32 *ports, afs_int32 portCount,
+ struct bc_dumpSchedule *dsptr, int append, int dontExecute)
{
register int i;
register afs_int32 code;
*/
afs_int32
-bc_FindDumpSlot(dumpID, port)
- afs_int32 dumpID;
- afs_int32 port;
+bc_FindDumpSlot(afs_int32 dumpID, afs_int32 port)
{
int i;
* label a tape
*/
-bc_LabelTape(afsname, pname, size, config, port)
- char *afsname, *pname;
- struct bc_config *config;
- afs_int32 port;
- afs_int32 size;
+int
+bc_LabelTape(char *afsname, char *pname, afs_int32 size,
+ struct bc_config *config, afs_int32 port)
{
struct rx_connection *tconn;
afs_int32 code = 0;
* a tape
*/
-bc_ReadLabel(config, port)
- struct bc_config *config;
- afs_int32 port;
+int
+bc_ReadLabel(struct bc_config *config, afs_int32 port)
{
struct rx_connection *tconn;
struct tc_tapeLabel label;
printf("Tape read was labelled : <NULL> size : %u\n", label.size);
} else if (!label.tapeId) {
printf("Tape read was labelled : %s size : %lu Kbytes\n", tname,
- label.size);
+ (long unsigned int) label.size);
} else {
printf("Tape read was labelled : %s (%lu) size : %lu Kbytes\n", tname,
- label.tapeId, label.size);
+ (long unsigned int) label.tapeId, (long unsigned int) label.size);
}
return 0;
}
-bc_ScanDumps(config, dbAddFlag, port)
- struct bc_config *config;
- afs_int32 dbAddFlag;
- afs_int32 port;
+int
+bc_ScanDumps(struct bc_config *config, afs_int32 dbAddFlag, afs_int32 port)
{
struct rx_connection *tconn;
statusP statusPtr;
/* get a connection to the tape controller */
afs_int32
-bc_GetConn(aconfig, aport, tconn)
- struct bc_config *aconfig;
- afs_int32 aport;
- struct rx_connection **tconn;
+bc_GetConn(struct bc_config *aconfig, afs_int32 aport,
+ struct rx_connection **tconn)
{
- afs_int32 code = 0;
afs_uint32 host;
unsigned short port;
static struct rx_securityClass *rxsc;
* -1 - not compatible
*/
-CheckTCVersion(tconn)
- struct rx_connection *tconn;
+int
+CheckTCVersion(struct rx_connection *tconn)
{
struct tc_tcInfo tci;
afs_int32 code;
return 0;
}
-ConnectButc(config, port, tconn)
- struct bc_config *config;
- afs_int32 port;
- struct rx_connection **tconn;
+int
+ConnectButc(struct bc_config *config, afs_int32 port,
+ struct rx_connection **tconn)
{
afs_int32 code;
#include <afs/bubasics.h>
#include "bc.h"
#include "error_macros.h"
+#include "bucoord_prototypes.h"
/* code to manage dump schedules
* specific to the ubik database implementation
*/
-afs_int32 bc_UpdateDumpSchedule();
extern struct bc_config *bc_globalConfig;
extern struct udbHandleS udbHandle;
extern char *whoami;
-static ListDumpSchedule();
+static int ListDumpSchedule(struct bc_dumpSchedule *adump, int alevel);
/* ------------------------------------
* command level routines
register struct cmd_item *ti;
udbClientTextP ctPtr;
- afs_int32 bc_ParseExpiration();
-
/* if an expiration date has been specified */
if (as->parms[1].items) {
code = bc_ParseExpiration(&as->parms[1], &expType, &expDate);
register int i;
register struct bc_dumpSchedule *child;
- char *tailCompPtr();
-
/* sanity check for loops */
if (alevel > 100) {
printf("backup: recursing listing dump schedule\n");
udbClientTextP ctPtr;
register int code;
- afs_int32 bc_ParseExpiration();
-
/* if an expiration date has been specified */
if (as->parms[1].items) {
code = bc_ParseExpiration(&as->parms[1], &expType, &expDate);
* ------------------------------------
*/
-bc_ParseDumpSchedule()
+int
+bc_ParseDumpSchedule(void)
{
char tbuffer[1024];
char dsname[256], period[64];
return 0;
}
-
-bc_SaveDumpSchedule()
+int
+bc_SaveDumpSchedule(void)
{
struct bc_dumpSchedule *tdump;
udbClientTextP ctPtr;
afs_int32 code = 0;
extern struct bc_config *bc_globalConfig;
- extern afs_int32 filesize();
/* setup the right ptr */
ctPtr = &bc_globalConfig->configText[TB_DUMPSCHEDULE];
*/
afs_int32
-bc_UpdateDumpSchedule()
+bc_UpdateDumpSchedule(void)
{
struct bc_dumpSchedule *dumpPtr, *nextDumpPtr;
struct udbHandleS *uhptr = &udbHandle;
*/
afs_int32
-bc_ParseExpiration(paramPtr, expType, expDate)
- struct cmd_parmdesc *paramPtr;
- afs_int32 *expType;
- afs_int32 *expDate;
+bc_ParseExpiration(struct cmd_parmdesc *paramPtr, afs_int32 *expType,
+ afs_int32 *expDate)
{
struct cmd_item *itemPtr, *tempPtr;
struct ktime_date kt;
#include <afs/stds.h>
#include <sys/types.h>
+#include <sys/stat.h>
+
#ifdef AFS_AIX32_ENV
#include <signal.h>
#endif
#include <netinet/in.h>
#include <netdb.h>
#endif
+
#include <errno.h>
#include <afs/cmd.h>
#include <rx/rx.h>
int localauth, interact;
char tcell[64];
-extern int bc_AddDumpCmd();
-extern int bc_AddHostCmd();
-extern int bc_AddVolEntryCmd();
-extern int bc_AddVolSetCmd();
-/* extern int bc_CheckDumpStatCmd(); */
-extern int bc_DeleteDumpCmd();
-extern int bc_DeleteHostCmd();
-extern int bc_DeleteVolEntryCmd();
-extern int bc_DeleteVolSetCmd();
-extern int bc_DiskRestoreCmd();
-extern int bc_VolsetRestoreCmd();
-extern int bc_DumpCmd();
-extern int bc_GetTapeStatusCmd();
-extern int bc_JobsCmd();
-extern int bc_KillCmd();
-extern int bc_LabelTapeCmd();
-extern int bc_ListDumpScheduleCmd();
-extern int bc_ListHostsCmd();
-extern int bc_ListVolSetCmd();
-extern int bc_QuitCmd();
-extern int bc_ReadLabelCmd();
-extern int bc_ScanDumpsCmd();
-extern int bc_SetExpCmd();
-extern int bc_VolRestoreCmd();
-extern int bc_dblookupCmd();
-extern int bc_dbVerifyCmd();
-extern int bc_deleteDumpCmd();
-extern int bc_dumpInfoCmd();
-extern int bc_restoreDbCmd();
-extern int bc_saveDbCmd();
-
/*
* Global configuration information for the Backup Coordinator.
*/
/* dummy routine for the audit work. It should do nothing since audits */
/* occur at the server level and bos is not a server. */
-osi_audit()
+int
+osi_audit(void)
{
return 0;
}
* in this module.
*/
void
-InitErrTabs()
+InitErrTabs(void)
{
initialize_ACFG_error_table();
initialize_KA_error_table();
* not dealt with by standard errno and com_err stuff.
*/
void
-bc_HandleMisc(code)
- afs_int32 code;
+bc_HandleMisc(afs_int32 code)
{
if (((code <= VMOVED) && (code >= VSALVAGE)) || (code < 0)) {
switch (code) {
}
/* Return true if line is all whitespace */
-static
-LineIsBlank(aline)
- register char *aline;
+static int
+LineIsBlank(char *aline)
{
register int tc;
- while (tc = *aline++)
+ while ((tc = *aline++))
if ((tc != ' ') && (tc != '\t') && (tc != '\n'))
return (0);
*/
afs_int32
-bc_InitTextConfig()
+bc_InitTextConfig(void)
{
udbClientTextP ctPtr;
int i;
- afs_int32 code = 0;
extern struct bc_config *bc_globalConfig;
*/
static int
-backupInit()
+backupInit(void)
{
register afs_int32 code;
static int initd = 0; /* ever called? */
#define unlock_Dispatch() ReleaseWriteLock(&dispatchLock)
afs_int32
-doDispatch(targc, targv, dispatchCount)
- char *targv[MAXV];
- afs_int32 targc;
- afs_int32 dispatchCount; /* to prevent infinite recursion */
+doDispatch(afs_int32 targc,
+ char *targv[MAXV],
+ afs_int32 dispatchCount) /* to prevent infinite recursion */
{
char *sargv[MAXV];
afs_int32 sargc;
}
static void
-add_std_args(ts)
- register struct cmd_syndesc *ts;
+add_std_args(struct cmd_syndesc *ts)
{
cmd_Seek(ts, 14);
cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
}
-
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{ /*main */
char *targv[MAXV]; /*Ptr to parsed argv stuff */
afs_int32 targc; /*Num parsed arguments */
* regular expression encountered.
*/
+#include "regex.h"
+
/*
* constants for re's
*/
static char expbuf[ESIZE], *braslist[NBRA], *braelist[NBRA];
static char circf;
-static int advance();
-static int backref();
-static int cclass();
+static int advance(char *, char *);
+static int backref(int i, char *);
+static int cclass(char *, char, int);
/*
* compile the regular expression argument into a dfa
*/
char *
-re_comp(sp)
- register char *sp;
+re_comp(const char *sp)
{
register int c;
register char *ep = expbuf;
}
static int
-cclass(set, c, af)
- register char *set, c;
- int af;
+cclass(char *set, char c, int af)
{
register int n;
return (!af);
}
-static
-backref(i, lp)
- register int i;
- register char *lp;
+static int
+backref(int i, char *lp)
{
register char *bp;
* try to match the next thing in the dfa
*/
static int
-advance(lp, ep)
- register char *lp, *ep;
+advance(char *lp, char *ep)
{
register char *curlp;
int ct, i;
return (0);
case CBRA:
- braslist[*ep++] = lp;
+ braslist[(int) *ep++] = lp;
continue;
case CKET:
- braelist[*ep++] = lp;
+ braelist[(int) *ep++] = lp;
continue;
case CBACK:
while (backref(i, lp))
lp += ct;
while (lp >= curlp) {
- if (rv = advance(lp, ep))
+ if ((rv = advance(lp, ep)))
return (rv);
lp -= ct;
}
star:
do {
lp--;
- if (rv = advance(lp, ep))
+ if ((rv = advance(lp, ep)))
return (rv);
} while (lp > curlp);
return (0);
* match the argument string against the compiled re
*/
int
-re_exec(p1)
- register char *p1;
+re_exec(const char *p1)
{
register char *p2 = expbuf;
register int c;
do {
if (*p1 != c)
continue;
- if (rv = advance(p1, p2))
+ if ((rv = advance(p1, p2)))
return (rv);
} while (*p1++);
return (0);
* regular algorithm
*/
do
- if (rv = advance(p1, p2))
+ if ((rv = advance(p1, p2)))
return (rv);
while (*p1++);
return (0);
--- /dev/null
+/* Copyright 2000, International Business Machines Corporation and others.
+ * All Rights Reserved.
+ *
+ * This software has been released under the terms of the IBM Public
+ * License. For details, see the LICENSE file in the top-level source
+ * directory or online at http://www.openafs.org/dl/license10.html
+ */
+
+#ifndef _BUCOORD_REGEX_H
+#define _BUCOORD_REGEX_H
+/* regex.c */
+extern char *re_comp(const char *sp);
+extern int re_exec(const char *p1);
+#endif
#include <afs/budb.h>
#include <afs/vlserver.h>
#include "error_macros.h"
+#include "bucoord_prototypes.h"
extern struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
extern char *whoami;
};
/* strip .backup from the end of a name */
-static
-StripBackup(aname)
- register char *aname;
+static int
+StripBackup(char *aname)
{
int j;
- if (j = BackupName(aname)) {
+ if ((j = BackupName(aname))) {
aname[j] = 0;
return 0;
}
}
int
-BackupName(aname)
- char *aname;
+BackupName(char *aname)
{
int j;
return 0;
}
-extractTapeSeq(tapename)
- char *tapename;
+int
+extractTapeSeq(char *tapename)
{
char *sptr;
}
void
-viceName(value)
- long value;
+viceName(long value)
{
char *alph;
int r;
* entry:
* aindex - index into bc_dumpTasks that describes this dump.
*/
-bc_Restorer(aindex)
- afs_int32 aindex;
+int
+bc_Restorer(afs_int32 aindex)
{
struct bc_dumpTask *dumpTaskPtr;
struct dumpinfo *dumpinfolist = NULL;
struct dumpinfo *pdi, *ndi, *di, *dlevels;
- struct volinfo *pvi, *nvi, *vi;
+ struct volinfo *nvi, *vi;
afs_int32 lvl, lv;
int num_dlevels = 20;
time_t did;
int foundtape, c;
- extern statusP createStatusNode();
- extern statusP findStatus();
-
dlevels = (struct dumpinfo *) malloc(num_dlevels * sizeof(*dlevels));
dumpTaskPtr = &bc_dumpTasks[aindex];
#include <rx/rx.h>
/* services available on incoming message port */
-BC_Print(acall, acode, aflags, amessage)
- struct rx_call *acall;
- afs_int32 acode, aflags;
- char *amessage;
+int
+BC_Print(struct rx_call *acall, afs_int32 acode, afs_int32 aflags,
+ char *amessage)
{
struct rx_connection *tconn;
struct rx_peer *tpeer;
#include <afs/bubasics.h>
#include "bc.h"
#include "error_macros.h"
-
+#include "bucoord_prototypes.h"
extern dlqlinkT statusHead; /* chain of status blocks */
extern struct Lock statusQueueLock; /* access control for status chain */
*/
void
-initStatus()
+initStatus(void)
{
dlqInit(&statusHead);
Lock_Init(&statusQueueLock);
/* lock managment */
void
-lock_Status()
+lock_Status(void)
{
ObtainWriteLock(&statusQueueLock);
}
void
-unlock_Status()
+unlock_Status(void)
{
ReleaseWriteLock(&statusQueueLock);
}
void
-lock_cmdLine()
+lock_cmdLine(void)
{
ObtainWriteLock(&cmdLineLock);
}
-
void
-unlock_cmdLine()
+unlock_cmdLine(void)
{
ReleaseWriteLock(&cmdLineLock);
}
/* general */
void
-clearStatus(taskId, flags)
- afs_uint32 taskId;
- afs_uint32 flags;
+clearStatus(afs_uint32 taskId, afs_uint32 flags)
{
statusP ptr;
- extern statusP findStatus();
-
ObtainWriteLock(&statusQueueLock);
ptr = findStatus(taskId);
if (ptr == 0) {
}
statusP
-createStatusNode()
+createStatusNode(void)
{
statusP ptr;
}
void
-deleteStatusNode(ptr)
- statusP ptr;
+deleteStatusNode(statusP ptr)
{
ObtainWriteLock(&statusQueueLock);
dlqUnlink((dlqlinkP) ptr);
}
statusP
-findStatus(taskId)
- afs_uint32 taskId;
+findStatus(afs_uint32 taskId)
{
statusP ptr = 0;
dlqlinkP dlqPtr;
}
void
-setStatus(taskId, flags)
- afs_uint32 taskId;
- afs_uint32 flags;
+setStatus(afs_uint32 taskId, afs_uint32 flags)
{
statusP ptr;
#include "bc.h"
#include "error_macros.h"
#include <errno.h>
-
+#include "bucoord_prototypes.h"
+
/* code to manage tape hosts
* specific to the ubik database implementation
*/
-afs_int32 bc_UpdateHosts();
extern struct bc_config *bc_globalConfig;
extern struct udbHandleS udbHandle;
extern char *whoami;
* ------------------------------------
*/
-bc_ClearHosts()
+int
+bc_ClearHosts(void)
{
register struct bc_hostEntry *tentry, *temp;
*/
int
-bc_ParseHosts()
+bc_ParseHosts(void)
{
char tbuffer[256];
char hostName[256];
* 2) transmit to ubik server
*/
-bc_SaveHosts()
+int
+bc_SaveHosts(void)
{
register afs_int32 code = 0;
}
afs_int32
-bc_UpdateHosts()
+bc_UpdateHosts(void)
{
struct udbHandleS *uhptr = &udbHandle;
udbClientTextP ctPtr;
#include "bc.h"
#include "error_macros.h"
-
-/* protos */
-afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *);
-afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *, afs_int32 );
-afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *) ;
-afs_int32 bcdb_deleteDump(afs_int32, afs_int32, afs_int32, budb_dumpsList *);
-/*note the pinter to the function comes from ubik/ubikclient ubik_Call function.*/
-afs_int32 bcdb_listDumps (afs_int32, afs_int32,afs_int32,afs_int32, budb_dumpsList *,
- budb_dumpsList *);
-afs_int32 bcdb_DeleteVDP(char *, char *, afs_int32 );
-afs_int32 bcdb_FindClone(afs_int32, char *, afs_int32 *);
+#include "bucoord_prototypes.h"
extern char *whoami;
return (code);
}
-afs_int32 bcdb_listDumps (afs_int32 sflags, afs_int32 groupId,afs_int32 fromTime, afs_int32 toTime,budb_dumpsList *dumps, budb_dumpsList *flags)
+afs_int32 bcdb_listDumps (afs_int32 sflags, afs_int32 groupId,
+ afs_int32 fromTime, afs_int32 toTime,
+ budb_dumpsList *dumps, budb_dumpsList *flags)
{
afs_int32 code;
budb_dumpsList dumpsList, *dumpsPtr;
* the current multiple bcdb_ call algorithm.
*/
-bcdb_FindDump(volumeName, beforeDate, deptr)
- char *volumeName;
- afs_int32 beforeDate;
- struct budb_dumpEntry *deptr;
+int
+bcdb_FindDump(char *volumeName, afs_int32 beforeDate,
+ struct budb_dumpEntry *deptr)
{
afs_int32 code;
code =
* dumpID - id to lookup
* exit:
*/
-bcdb_FindDumpByID(dumpID, deptr)
- afs_int32 dumpID;
- register struct budb_dumpEntry *deptr;
+int
+bcdb_FindDumpByID(afs_int32 dumpID, struct budb_dumpEntry *deptr)
{
register afs_int32 code;
afs_int32 nextindex;
*/
afs_int32
-bcdb_FindLastVolClone(volSetName, dumpName, volName, clonetime)
- char *volSetName;
- char *dumpName;
- char *volName;
- afs_int32 *clonetime;
+bcdb_FindLastVolClone(char *volSetName, char *dumpName, char *volName,
+ afs_int32 *clonetime)
{
/* server notes
* search by dumpName
* Need new routine since params are two strings
*/
-bcdb_FindLatestDump(volSetName, dumpPath, deptr)
- char *volSetName;
- char *dumpPath;
- struct budb_dumpEntry *deptr;
+int
+bcdb_FindLatestDump(char *volSetName, char *dumpPath,
+ struct budb_dumpEntry *deptr)
{
afs_int32 code;
code =
* tapeName: name of tape
*/
-bcdb_FindTape(dumpid, tapeName, teptr)
- afs_int32 dumpid;
- char *tapeName;
- struct budb_tapeEntry *teptr;
+int
+bcdb_FindTape(afs_int32 dumpid, char *tapeName,
+ struct budb_tapeEntry *teptr)
{
budb_tapeList tl;
afs_int32 next;
return (code);
}
-bcdb_FindTapeSeq(dumpid, tapeSeq, teptr)
- afs_int32 dumpid;
- afs_int32 tapeSeq;
- struct budb_tapeEntry *teptr;
+int
+bcdb_FindTapeSeq(afs_int32 dumpid, afs_int32 tapeSeq,
+ struct budb_tapeEntry *teptr)
{
budb_tapeList tl;
afs_int32 next;
*/
afs_int32
-bcdb_FindVolumes(dumpID, volumeName, returnArray, last, next, maxa, nEntries)
- afs_int32 dumpID;
- char *volumeName;
- struct budb_volumeEntry *returnArray;
- afs_int32 last;
- afs_int32 *next;
- afs_int32 maxa;
- afs_int32 *nEntries;
+bcdb_FindVolumes(afs_int32 dumpID, char *volumeName,
+ struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next, afs_int32 maxa,
+ afs_int32 *nEntries)
{
budb_volumeList vl;
afs_int32 dbTime;
return (code);
}
-
-bcdb_FinishDump(deptr)
- register struct budb_dumpEntry *deptr;
+int
+bcdb_FinishDump(register struct budb_dumpEntry *deptr)
{
afs_int32 code;
code = ubik_BUDB_FinishDump(udbHandle.uh_client, 0, deptr);
return (code);
}
-bcdb_FinishTape(teptr)
- register struct budb_tapeEntry *teptr;
+int
+bcdb_FinishTape(register struct budb_tapeEntry *teptr)
{
afs_int32 code;
code = ubik_BUDB_FinishTape(udbHandle.uh_client, 0, teptr);
*/
afs_int32
-bcdb_LookupVolume(volumeName, returnArray, last, next, maxa, nEntries)
- char *volumeName;
- struct budb_volumeEntry *returnArray;
- afs_int32 last;
- afs_int32 *next;
- afs_int32 maxa;
- afs_int32 *nEntries;
+bcdb_LookupVolume(char *volumeName, struct budb_volumeEntry *returnArray,
+ afs_int32 last, afs_int32 *next, afs_int32 maxa,
+ afs_int32 *nEntries)
{
budb_volumeList vl;
afs_int32 dbTime;
return (0);
}
-
-bcdb_UseTape(teptr, newFlag)
- register struct budb_tapeEntry *teptr;
- afs_int32 *newFlag;
+int
+bcdb_UseTape(struct budb_tapeEntry *teptr, afs_int32 *newFlag)
{
afs_int32 code;
code = ubik_BUDB_UseTape(udbHandle.uh_client, 0, teptr, newFlag);
* ctPtr - ptr to client structure with all the required information
*/
+int
bcdb_GetTextFile(register udbClientTextP ctPtr)
{
afs_int32 bufferSize;
* filename - where to get the text from
*/
-bcdb_SaveTextFile(ctPtr)
- udbClientTextP ctPtr;
+int
+bcdb_SaveTextFile(udbClientTextP ctPtr)
{
afs_int32 bufferSize;
afs_int32 offset, chunkSize, fileSize;
charListT charList;
afs_int32 code = 0;
- afs_int32 filesize();
/* allocate a buffer */
bufferSize = 1024;
return (code);
}
-bcdb_FindLastTape(dumpID, dumpEntry, tapeEntry, volEntry)
- afs_int32 dumpID;
- struct budb_dumpEntry *dumpEntry;
- struct budb_tapeEntry *tapeEntry;
- struct budb_volumeEntry *volEntry;
+bcdb_FindLastTape(afs_int32 dumpID, struct budb_dumpEntry *dumpEntry,
+ struct budb_tapeEntry *tapeEntry,
+ struct budb_volumeEntry *volEntry)
{
return (ubik_BUDB_FindLastTape(udbHandle.uh_client, 0, dumpID, dumpEntry,
tapeEntry, volEntry));
}
-bcdb_MakeDumpAppended(appendedDumpID, initialDumpID, startTapeSeq)
- afs_int32 appendedDumpID;
- afs_int32 initialDumpID;
- afs_int32 startTapeSeq;
+bcdb_MakeDumpAppended(afs_int32 appendedDumpID, afs_int32 initialDumpID,
+ afs_int32 startTapeSeq)
{
return (ubik_BUDB_MakeDumpAppended(udbHandle.uh_client, 0, appendedDumpID,
initialDumpID, startTapeSeq));
*/
afs_int32
-filesize(stream)
- FILE *stream;
+filesize(FILE *stream)
{
afs_int32 offset;
afs_int32 size;
* n - fail
*/
-bc_LockText(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_LockText(udbClientTextP ctPtr)
{
afs_int32 code;
afs_int32 timeout, j = 0;
* n - fail
*/
-bc_UnlockText(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_UnlockText(udbClientTextP ctPtr)
{
afs_int32 code = 0;
* n - out of date or error
*/
-bc_CheckTextVersion(ctPtr)
- register udbClientTextP ctPtr;
+int
+bc_CheckTextVersion(udbClientTextP ctPtr)
{
afs_int32 code;
afs_uint32 tversion;
/* vldbClientInit
* Initialize a client for the vl ubik database.
*/
-vldbClientInit(noAuthFlag, localauth, cellName, cstruct, ttoken)
- int noAuthFlag;
- int localauth;
- char *cellName;
- struct ubik_client **cstruct;
- struct ktc_token *ttoken;
+int
+vldbClientInit(int noAuthFlag, int localauth, char *cellName,
+ struct ubik_client **cstruct,
+ struct ktc_token *ttoken)
{
afs_int32 code = 0;
struct afsconf_dir *acdir;
- struct rc_securityClass *sc;
+ struct rx_securityClass *sc;
afs_int32 i, scIndex = 0; /* Index of Rx security object - noauth */
struct afsconf_cell info;
struct ktc_principal sname;
*/
afs_int32
-udbClientInit(noAuthFlag, localauth, cellName)
- int noAuthFlag;
- int localauth;
- char *cellName;
+udbClientInit(int noAuthFlag, int localauth, char *cellName)
{
struct ktc_principal principal;
struct ktc_token token;
*/
afs_int32
-ubik_Call_SingleServer(aproc, aclient, aflags, p1, p2, p3, p4, p5, p6, p7, p8,
- p9, p10, p11, p12, p13, p14, p15, p16)
- register struct ubik_client *aclient;
- int (*aproc) ();
- afs_int32 aflags;
- char *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12, *p13,
- *p14, *p15, *p16;
+ubik_Call_SingleServer(int (*aproc) (), struct ubik_client *aclient,
+ afs_int32 aflags, char *p1, char *p2, char *p3,
+ char *p4, char *p5, char *p6, char *p7, char *p8,
+ char *p9, char *p10, char *p11, char *p12, char *p13,
+ char *p14, char *p15, char *p16)
{
register afs_int32 code;
afs_int32 someCode, newHost, thisHost;
* n - error.
*/
-udbLocalInit()
+int
+udbLocalInit(void)
{
afs_int32 serverList[MAXSERVERS];
char hostname[256];
#include <afs/bubasics.h>
#include "bc.h"
#include "error_macros.h"
-
+#include "bucoord_prototypes.h"
+
/* code to manage volumesets
* specific to the ubik database implementation
*/
-afs_int32 bc_UpdateVolumeSet();
extern struct bc_config *bc_globalConfig;
extern struct udbHandleS udbHandle;
extern char *whoami;
-extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cf, char *name);
-extern void FreeVolumeSet(struct bc_volumeSet *avset);
-static ListVolSet();
+static int ListVolSet(struct bc_volumeSet *aset);
/* ------------------------------------
* command level routines
}
/* figure out volume set to list */
- if (ti = as->parms[0].items) {
+ if ((ti = as->parms[0].items)) {
/* for each volume set in the command item list */
for (; ti; ti = ti->next) {
tset = bc_FindVolumeSet(bc_globalConfig, ti->data);
* ------------------------------------
*/
-bc_ClearVolumeSets()
+int
+bc_ClearVolumeSets(void)
{
- struct udbHandleS *uhptr = &udbHandle;
struct bc_volumeSet *vsPtr, *vsNextPtr, **vsPrev;
extern struct bc_config *bc_globalConfig;
*/
int
-bc_ParseVolumeSet()
+bc_ParseVolumeSet(void)
{
- static char rn[] = "bc_ParseVolumeSet"; /*Routine name */
char tbuffer[1024]; /*Buffer for reading config file */
char vsname[256]; /*Volume set name */
char serverName[256]; /*Server name */
char partName[256]; /*Partition name */
register struct bc_volumeEntry *tve; /*Ptr to generated volume spec struct */
- register struct bc_volumeSet *tvs; /*Ptr to volume set struct */
+ register struct bc_volumeSet *tvs = NULL; /*Ptr to volume set struct */
struct bc_volumeEntry **ppve, *pve;
struct bc_volumeSet **ppvs, *pvs;
register afs_int32 code; /*Generalized return code */
* save the current volume set information to disk
*/
-bc_SaveVolumeSet()
+int
+bc_SaveVolumeSet(void)
{
register afs_int32 code = 0;
register struct bc_volumeSet *tset;
}
afs_int32
-bc_UpdateVolumeSet()
+bc_UpdateVolumeSet(void)
{
struct udbHandleS *uhptr = &udbHandle;
udbClientTextP ctPtr;
/* ********************************************************************* */
afs_int32
-bc_GetEntryByID(uclient, volID, volType, vldbEntryPtr)
- struct ubik_client *uclient;
- afs_int32 volID;
- afs_int32 volType;
- struct vldbentry *vldbEntryPtr;
+bc_GetEntryByID(struct ubik_client *uclient, afs_int32 volID,
+ afs_int32 volType, struct vldbentry *vldbEntryPtr)
{
afs_int32 code = 0;
*/
afs_int32
-volImageTime(serv, part, volid, voltype, clDatePtr)
- afs_int32 serv;
- afs_int32 part;
- afs_int32 volid;
- afs_int32 voltype;
- afs_int32 *clDatePtr;
+volImageTime(afs_int32 serv, afs_int32 part, afs_int32 volid,
+ afs_int32 voltype, afs_int32 *clDatePtr)
{
afs_int32 code = 0;
struct volintInfo *viptr;
projects / packages / o / openafs.git / commitdiff