int
convert_cell_to_ubik(struct afsconf_cell *cellinfo, afs_uint32 *myHost,
afs_uint32 *serverList)
{
int i;
char hostname[64];
struct hostent *th;
/* get this host */
gethostname(hostname, sizeof(hostname));
th = gethostbyname(hostname);
if (!th) {
printf("prserver: couldn't get address of this host.\n");
BUDB_EXIT(1);
}
memcpy(myHost, th->h_addr, sizeof(afs_uint32));
for (i = 0; i < cellinfo->numServers; i++)
/* omit my host from serverList */
if (cellinfo->hostAddr[i].sin_addr.s_addr != *myHost)
*serverList++ = cellinfo->hostAddr[i].sin_addr.s_addr;
*serverList = 0; /* terminate list */
return 0;
}
void
consistencyCheckDb(void)
{
/* do consistency checks on structure sizes */
if ((sizeof(struct htBlock) > BLOCKSIZE)
|| (sizeof(struct vfBlock) > BLOCKSIZE)
|| (sizeof(struct viBlock) > BLOCKSIZE)
|| (sizeof(struct dBlock) > BLOCKSIZE)
|| (sizeof(struct tBlock) > BLOCKSIZE)
) {
fprintf(stderr, "Block layout error!\n");
BUDB_EXIT(99);
}
}
afs_int32
writeStructHeader(int fid, afs_int32 type)
{
struct structDumpHeader hostDumpHeader, netDumpHeader;
hostDumpHeader.type = type;
hostDumpHeader.structversion = 1;
switch (type) {
case SD_DBHEADER:
hostDumpHeader.size = sizeof(struct DbHeader);
break;
case SD_DUMP:
hostDumpHeader.size = sizeof(struct budb_dumpEntry);
break;
case SD_TAPE:
hostDumpHeader.size = sizeof(struct budb_tapeEntry);
break;
case SD_VOLUME:
hostDumpHeader.size = sizeof(struct budb_volumeEntry);
break;
case SD_END:
hostDumpHeader.size = 0;
break;
default:
LogError(0, "writeStructHeader: invalid type %d\n", type);
BUDB_EXIT(1);
}
structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);
if (canWrite(fid) <= 0)
return (BUDB_DUMPFAILED);
if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
sizeof(netDumpHeader))
return (BUDB_DUMPFAILED);
haveWritten(sizeof(netDumpHeader));
return (0);
}
afs_int32
writeTextHeader(int fid, afs_int32 type)
{
struct structDumpHeader hostDumpHeader, netDumpHeader;
hostDumpHeader.structversion = 1;
switch (type) {
case TB_DUMPSCHEDULE:
hostDumpHeader.type = SD_TEXT_DUMPSCHEDULE;
break;
case TB_VOLUMESET:
hostDumpHeader.type = SD_TEXT_VOLUMESET;
break;
case TB_TAPEHOSTS:
hostDumpHeader.type = SD_TEXT_TAPEHOSTS;
break;
default:
LogError(0, "writeTextHeader: invalid type %d\n", type);
BUDB_EXIT(1);
}
hostDumpHeader.size = ntohl(db.h.textBlock[type].size);
structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);
if (canWrite(fid) <= 0)
return (BUDB_DUMPFAILED);
if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
sizeof(netDumpHeader))
return (BUDB_DUMPFAILED);
haveWritten(sizeof(netDumpHeader));
return (0);
}
int
main(int argc, char **argv)
{
char *whoami = argv[0];
char *dbNamePtr = 0;
struct afsconf_cell cellinfo;
time_t currentTime;
afs_int32 code = 0;
afs_uint32 host = ntohl(INADDR_ANY);
char clones[MAXHOSTSPERCELL];
struct rx_service *tservice;
struct rx_securityClass **securityClasses;
afs_int32 numClasses;
extern int rx_stackSize;
#ifdef AFS_NT40_ENV
/* initialize winsock */
if (afs_winsockInit() < 0) {
ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0, argv[0], 0);
fprintf(stderr, "%s: Couldn't initialize winsock.\n", whoami);
exit(1);
}
#endif
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
sigaction(SIGABRT, &nsa, NULL);
#endif
osi_audit_init();
osi_audit(BUDB_StartEvent, 0, AUD_END);
initialize_BUDB_error_table();
initializeArgHandler();
/* Initialize dirpaths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
afs_com_err(whoami, errno, "; Unable to obtain AFS server directory.");
exit(2);
}
memset(globalConfPtr, 0, sizeof(*globalConfPtr));
/* set default configuration values */
strcpy(dbDir, AFSDIR_SERVER_DB_DIRPATH);
strcat(dbDir, "/");
globalConfPtr->databaseDirectory = dbDir;
globalConfPtr->databaseName = DEFAULT_DBPREFIX;
strcpy(cellConfDir, AFSDIR_SERVER_ETC_DIRPATH);
globalConfPtr->cellConfigdir = cellConfDir;
/* open the log file */
/*
globalConfPtr->log = fopen(DEFAULT_LOGNAME,"a");
if ( globalConfPtr->log == NULL )
{
printf("Can't open log file %s - aborting\n", DEFAULT_LOGNAME);
BUDB_EXIT(-1);
}
*/
srandom(1);
#ifdef AFS_PTHREAD_ENV
SetLogThreadNumProgram( rx_GetThreadNum );
#endif
/* process the user supplied args */
helpOption = 1;
code = cmd_Dispatch(argc, argv);
if (code)
ERROR(code);
/* exit if there was a help option */
if (helpOption)
BUDB_EXIT(0);
/* open the log file */
globalConfPtr->log = fopen(AFSDIR_SERVER_BUDBLOG_FILEPATH, "a");
if (globalConfPtr->log == NULL) {
printf("Can't open log file %s - aborting\n",
AFSDIR_SERVER_BUDBLOG_FILEPATH);
BUDB_EXIT(-1);
}
/* keep log closed so can remove it */
fclose(globalConfPtr->log);
/* open the cell's configuration directory */
LogDebug(4, "opening %s\n", globalConfPtr->cellConfigdir);
BU_conf = afsconf_Open(globalConfPtr->cellConfigdir);
if (BU_conf == 0) {
LogError(code, "Failed getting cell info\n");
afs_com_err(whoami, code, "Failed getting cell info");
ERROR(BUDB_NOCELLS);
}
code = afsconf_GetLocalCell(BU_conf, lcell, sizeof(lcell));
if (code) {
LogError(0, "** Can't determine local cell name!\n");
ERROR(code);
}
if (globalConfPtr->myHost == 0) {
/* if user hasn't supplied a list of servers, extract server
* list from the cell's database
*/
LogDebug(1, "Using server list from %s cell database.\n", lcell);
code = afsconf_GetExtendedCellInfo (BU_conf, lcell, 0, &cellinfo,
clones);
code =
convert_cell_to_ubik(&cellinfo, &globalConfPtr->myHost,
globalConfPtr->serverList);
if (code)
ERROR(code);
}
/* initialize audit user check */
osi_audit_set_user_check(BU_conf, BU_IsLocalRealmMatch);
/* initialize ubik */
ubik_SetClientSecurityProcs(afsconf_ClientAuth, afsconf_UpToDate, BU_conf);
ubik_SetServerSecurityProcs(afsconf_BuildServerSecurityObjects,
afsconf_CheckAuth, BU_conf);
if (ubik_nBuffers == 0)
ubik_nBuffers = 400;
LogError(0, "Will allocate %d ubik buffers\n", ubik_nBuffers);
asprintf(&dbNamePtr, "%s%s", globalConfPtr->databaseDirectory,
globalConfPtr->databaseName);
if (dbNamePtr == 0)
ERROR(-1);
rx_SetRxDeadTime(60); /* 60 seconds inactive before timeout */
if (rxBind) {
afs_int32 ccode;
if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
AFSDIR_SERVER_NETINFO_FILEPATH) {
char reason[1024];
ccode = afsconf_ParseNetFiles(SHostAddrs, NULL, NULL,
ADDRSPERSITE, reason,
AFSDIR_SERVER_NETINFO_FILEPATH,
AFSDIR_SERVER_NETRESTRICT_FILEPATH);
} else
{
ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
}
if (ccode == 1) {
host = SHostAddrs[0];
rx_InitHost(host, htons(AFSCONF_BUDBPORT));
}
}
/* Disable jumbograms */
rx_SetNoJumbo();
code = ubik_ServerInitByInfo (globalConfPtr->myHost,
htons(AFSCONF_BUDBPORT),
&cellinfo,
clones,
dbNamePtr, /* name prefix */
&BU_dbase);
if (code) {
LogError(code, "Ubik init failed\n");
afs_com_err(whoami, code, "Ubik init failed");
ERROR(code);
}
afsconf_BuildServerSecurityObjects(BU_conf, &securityClasses, &numClasses);
tservice =
rx_NewServiceHost(host, 0, BUDB_SERVICE, "BackupDatabase",
securityClasses, numClasses, BUDB_ExecuteRequest);
if (tservice == (struct rx_service *)0) {
LogError(0, "Could not create backup database rx service\n");
printf("Could not create backup database rx service\n");
BUDB_EXIT(3);
}
rx_SetMinProcs(tservice, 1);
rx_SetMaxProcs(tservice, lwps);
rx_SetStackSize(tservice, 10000);
/* allow super users to manage RX statistics */
rx_SetRxStatUserOk(BU_rxstat_userok);
/* misc. initialization */
/* database dump synchronization */
memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
Lock_Init(&dumpSyncPtr->ds_lock);
rx_StartServer(0); /* start handling requests */
code = InitProcs();
if (code)
ERROR(code);
currentTime = time(0);
LogError(0, "Ready to process requests at %s\n", ctime(¤tTime));
rx_ServerProc(NULL); /* donate this LWP */
error_exit:
osi_audit(BUDB_FinishEvent, code, AUD_END);
return (code);
}
int
argHandler(struct cmd_syndesc *as, void *arock)
{
/* globalConfPtr provides the handle for the configuration information */
/* database directory */
if (as->parms[0].items != 0) {
globalConfPtr->databaseDirectory = strdup(as->parms[0].items->data);
if (globalConfPtr->databaseDirectory == 0)
BUDB_EXIT(-1);
}
/* -cellservdb, cell configuration directory */
if (as->parms[1].items != 0) {
globalConfPtr->cellConfigdir = strdup(as->parms[1].items->data);
if (globalConfPtr->cellConfigdir == 0)
BUDB_EXIT(-1);
globalConfPtr->debugFlags |= DF_RECHECKNOAUTH;
}
/* truncate the database */
if (as->parms[2].items != 0)
truncateDatabase();
/* run without authentication */
if (as->parms[3].items != 0)
globalConfPtr->debugFlags |= DF_NOAUTH;
/* use small hash tables */
if (as->parms[4].items != 0)
globalConfPtr->debugFlags |= DF_SMALLHT;
/* user provided list of ubik database servers */
if (as->parms[5].items != 0)
parseServerList(as->parms[5].items);
/* user provided the number of ubik buffers */
if (as->parms[6].items != 0)
ubik_nBuffers = atoi(as->parms[6].items->data);
else
ubik_nBuffers = 0;
/* param 7 (-auditlog) handled below */
/* user provided the number of threads */
if (as->parms[8].items != 0) {
lwps = atoi(as->parms[8].items->data);
if (lwps > MAXLWP) {
printf ("Warning: '-p %d' is too big; using %d instead\n",
lwps, MAXLWP);
lwps = MAXLWP;
}
if (lwps < MINLWP) {
printf ("Warning: '-p %d' is too small; using %d instead\n",
lwps, MINLWP);
lwps = MINLWP;
}
}
/* user provided rxbind option */
if (as->parms[9].items != 0) {
rxBind = 1;
}
/* -audit-interface */
if (as->parms[10].items != 0) {
char *interface = as->parms[10].items->data;
if (osi_audit_interface(interface)) {
printf("Invalid audit interface '%s'\n", interface);
BUDB_EXIT(-1);
}
}
/* -auditlog */
/* needs to be after -audit-interface, so we osi_audit_interface
* before we osi_audit_file */
if (as->parms[7].items != 0) {
char *fileName = as->parms[7].items->data;
osi_audit_file(fileName);
}
return 0;
}
