//------------------------------------------------------------------------------------------------
// loades material list
//------------------------------------------------------------------------------------------------
int ap_Load_Material_List(char *p_File_Name, AUDIO_DATA * p_ad)
{
FILE *file = 0;
FILE *Material_file = 0;
char text[30] = "", error[MAX_FILENAME];
int i;
if (p_ad->p_Material)
return 0;
achdir(pSndArchive, p_ber->dir.sound_dir);
file = aopen(pSndArchive, p_File_Name, "r");
if (!file) {
//MessageBox(p_ad->hWnd,"Material list file not found","Error", MB_OK);
MyMessageBox(NULL, "##error_title", "##material_list_error", "");
kprintf(1, "Material list file not found");
return 0;
}
agets(text, 30, file);
p_ad->Size_of_Material_List = atoi(text);
p_ad->p_Material =
(MATERIAL_LIST_ITEM *) malloc((p_ad->Size_of_Material_List) *
sizeof(MATERIAL_LIST_ITEM));
if (!p_ad->p_Material) {
//MessageBox(p_ad->hWnd,"Unable to allocate memory for material list","Error",MB_OK);
kprintf(1, "Unable to allocate memory for material list");
MyMessageBox(NULL, "##error_title", "##material_list_error", "");
return 0;
}
for (i = 0; i < p_ad->Size_of_Material_List; i++) {
if(!agets(text, 30, file))
break;
newline_cut(text);
Material_file = aopen(pSndArchive, text, "rb");
if (!Material_file) {
sprintf(error, "%s not found", text);
//MessageBox(p_ad->hWnd,error,"Error", MB_OK);
kprintf(1, error);
}
else {
aread(&p_ad->p_Material[i], sizeof(MATERIAL_LIST_ITEM), 1,
Material_file);
aclose(Material_file);
}
}
aclose(file);
return 1;
}
char fn_Load_Triger(char *pFile, GAME_TRIGER * pTriger, GRAMMAR * pGr,
TRIGER_STRUCTURE * pTStruct)
{
FILE *file;
WCHAR wtext[128];
word wotext[128];
pTriger->lastcommand = 0;
file = aopen(b2_2d_font.pArchive, pFile, "rb");
aunicode(file);
if (!file)
return 0;
aseek(file, 2, SEEK_SET);
while (!aeof(file)) {
memset(wtext, 0, 128 * sizeof(WCHAR));
if(agets((char *) wotext, 256, file)) {
wchar_windows_to_linux(wotext, 128, wtext);
trig_Parse_LineU(wtext, &pTriger->command[pTriger->lastcommand], pTriger,
pGr, pTStruct);
}
}
aclose(file);
return 1;
}
char gr_Load_Grammar(char *pFile, GRAMMAR *pGr)
{
FILE *file;
char text[256];
GetPrivateProfileString("game","data_dir","c:\\",text,256,ini_file);
chdir(text);
file = aopen(pDataArchive, pFile, "r");
if(!file)
return 0;
pGr->LastMask = 0;
while(!aeof(file))
{
agets(text,256,file);
gr_Add_Mask(text, pGr);
strcpy(text,"");
}
aclose(file);
return 1;
}
//------------------------------------------------------------------------------------------------
// load list of bitmaps from APAK
//------------------------------------------------------------------------------------------------
BOOL ddx2LoadList(char *pFileName, APAK_HANDLE *pBmpArchive, char *p_bmp_dir)
{
int c;
char text[256];
FILE *file = 0;
DWORD Eplased = 0;
DWORD Start, Stop;
achdir(pBmpArchive, p_bmp_dir);
kprintf(1,(unsigned char *) "Kofola: - Load bitmap pro herni menu");
file = aopen(pBmpArchive, pFileName,"rb");
if(!file) {
kprintf(1,(unsigned char *) "File not found : %s",pFileName);
konec(TRUE);
}
c = 0;
Start = timeGetTime();
while(!aeof(file)) {
agets(text,256,file);
if(!aeof(file)) {
text[strlen(text)-1] = '\0';
ddx2LoadBitmapPos(c,text,pBmpArchive);
}
c++;
}
aclose(file);
Stop = timeGetTime();
kprintf(1, (unsigned char *) "--------------Total load time %.1f s -----------------", Eplased / 1000.0f);
return(TRUE);
}
dle_t *
amxml_parse_node_FILE(
FILE *file,
char **errmsg)
{
amgxml_t amgxml = {NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
GMarkupParser parser = {&amstart_element, &amend_element, &amtext,
NULL, NULL};
GMarkupParseFlags flags = 0;
GMarkupParseContext *context;
GError *gerror = NULL;
char *line;
(void)errmsg;
context = g_markup_parse_context_new(&parser, flags, &amgxml, NULL);
while ((line = agets(file)) != NULL && !gerror) {
g_markup_parse_context_parse(context, line, strlen(line), &gerror);
amfree(line);
}
if (!gerror)
g_markup_parse_context_end_parse(context, &gerror);
g_markup_parse_context_free(context);
if (gerror) {
if (errmsg)
*errmsg = stralloc(gerror->message);
g_error_free(gerror);
}
return amgxml.dles;
}
/* WARNING: Function accesses globals curstr, curlog, and curprog
* WARNING: Function has static member logline, returned via globals */
int
get_logline(
FILE * logf)
{
static char *logline = NULL;
char *logstr, *progstr;
char *s;
int ch;
amfree(logline);
while ((logline = agets(logf)) != NULL) {
if (logline[0] != '\0')
break;
amfree(logline);
}
if (logline == NULL) return 0;
curlinenum++;
s = logline;
ch = *s++;
/* continuation lines are special */
if(logline[0] == ' ' && logline[1] == ' ') {
curlog = L_CONT;
/* curprog stays the same */
skip_whitespace(s, ch);
curstr = s-1;
return 1;
}
/* isolate logtype field */
skip_whitespace(s, ch);
logstr = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
/* isolate program name field */
skip_whitespace(s, ch);
progstr = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
/* rest of line is logtype dependent string */
skip_whitespace(s, ch);
curstr = s - 1;
/* lookup strings */
for(curlog = L_MARKER; curlog != L_BOGUS; curlog--)
if(strcmp(logtype_str[curlog], logstr) == 0) break;
for(curprog = P_LAST; curprog != P_UNKNOWN; curprog--)
if(strcmp(program_str[curprog], progstr) == 0) break;
return 1;
}
static void
import_dumpdates(
amandates_t * amdp)
{
char *devname;
char *line;
char *fname;
int level = 0;
time_t dumpdate;
FILE *dumpdf;
char *s;
int ch;
devname = amname_to_devname(amdp->name);
if((dumpdf = fopen("/etc/dumpdates", "r")) == NULL) {
amfree(devname);
return;
}
for(; (line = agets(dumpdf)) != NULL; free(line)) {
if (line[0] == '\0')
continue;
s = line;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0') {
continue; /* no fname field */
}
fname = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0'; /* terminate fname */
skip_whitespace(s, ch);
if(ch == '\0' || sscanf(s - 1, "%d", &level) != 1) {
continue; /* no level field */
}
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0') {
continue; /* no dumpdate field */
}
dumpdate = unctime(s-1);
if(!g_str_equal(fname, devname) || level < 0 || level >= DUMP_LEVELS) {
continue;
}
if(dumpdate != -1 && dumpdate > amdp->dates[level]) {
if(!readonly) updated = 1;
amdp->dates[level] = dumpdate;
}
}
afclose(dumpdf);
amfree(devname);
}
char *
readline(
const char *prompt)
{
g_printf("%s", prompt);
fflush(stdout);
fflush(stderr);
return agets(stdin);
}
//------------------------------------------------------------------------------------------------
// Loads sample List
//------------------------------------------------------------------------------------------------
int ap_Load_Sound_List(AUDIO_DATA *p_ad, char *cFile, int iStart)
{
FILE *file;
char text[256];
int c = iStart;
int iMaterial = 0;
chdir(p_ad->Sound_Dir);
if(!strlen(cFile))
return 0;
achdir(pSndArchive, p_ad->Sound_Dir);
file = aopen(pSndArchive, cFile,"r");
if(!file)
{
kprintf(1,"Play list file not found");
return 0;
}
agets(text,255,file);
iMaterial = atoi(text);
while(!aeof(file))
{
memset(text, 0, 256);
agets(text,255,file);
if(!strlen(text))
break;
else
{
text[strlen(text)-1] = '\0';
ap_Load_Sample(c, text);
c++;
}
}
aclose(file);
return iMaterial;
}
char *
findpass(
char * disk,
char ** domain)
{
FILE *fp;
static char *buffer = NULL;
char *s, *d, *pw = NULL;
int ch;
char *qname;
*domain = NULL; /* just to be sure */
if ( (fp = fopen("/etc/amandapass", "r")) ) {
amfree(buffer);
for (; (buffer = agets(fp)) != NULL; free(buffer)) {
if (buffer[0] == '\0')
continue;
s = buffer;
ch = *s++;
skip_whitespace(s, ch); /* find start of disk name */
if (!ch || ch == '#') {
continue;
}
qname = s-1; /* start of disk name */
skip_quoted_string(s, ch);
if (ch && ch != '#') {
s[-1] = '\0'; /* terminate disk name */
d = unquote_string(qname);
if ((strcmp(d,"*") == 0) || (strcmp(disk, d) == 0)) {
skip_whitespace(s, ch); /* find start of password */
if (ch && ch != '#') {
pw = s - 1; /* start of password */
skip_non_whitespace_cs(s, ch);
s[-1] = '\0'; /* terminate password */
pw = stralloc(pw);
skip_whitespace(s, ch); /* find start of domain */
if (ch && ch != '#') {
*domain = s - 1; /* start of domain */
skip_non_whitespace_cs(s, ch);
s[-1] = '\0'; /* terminate domain */
*domain = stralloc(*domain);
}
}
amfree(d);
break;
}
amfree(d);
}
}
afclose(fp);
}
return pw;
}
//------------------------------------------------------------------------------------------------
// Loads sample List
//------------------------------------------------------------------------------------------------
int ap_Load_Sound_List(AUDIO_DATA * p_ad, char *cFile, int iStart)
{
FILE *file;
char text[256] = "";
int c = iStart;
int iMaterial = 0;
chdir(p_ber->dir.sound_dir);
if (!strlen(cFile))
return 0;
achdir(pSndArchive, p_ber->dir.sound_dir);
file = aopen(pSndArchive, cFile, "r");
if (!file) {
kprintf(1, "Play list file not found");
return 0;
}
if(agets(text, 255, file)) {
iMaterial = atoi(text);
while (!aeof(file)) {
memset(text, 0, 256);
if(!agets(text, 255, file) || !text[0])
break;
newline_cut(text);
if(!ap_Load_Sample(c, text)) {
// Loading failed - stop it
break;
}
c++;
}
}
aclose(file);
return iMaterial;
}
struct cmdargs *
getcmd(void)
{
char *line;
cmd_t cmd_i;
struct cmdargs *cmdargs = g_new0(struct cmdargs, 1);
if (isatty(0)) {
g_printf("%s> ", get_pname());
fflush(stdout);
line = agets(stdin);
} else {
line = agets(stdin);
}
if (line == NULL) {
line = stralloc("QUIT");
}
dbprintf(_("getcmd: %s\n"), line);
cmdargs->argv = split_quoted_strings(line);
cmdargs->argc = g_strv_length(cmdargs->argv);
cmdargs->cmd = BOGUS;
amfree(line);
if (cmdargs->argc < 1) {
return cmdargs;
}
for(cmd_i=BOGUS; cmdstr[cmd_i] != NULL; cmd_i++)
if(strcmp(cmdargs->argv[0], cmdstr[cmd_i]) == 0) {
cmdargs->cmd = cmd_i;
return cmdargs;
}
return cmdargs;
}
int
read_tapelist(
char *tapefile)
{
tape_t *tp;
FILE *tapef;
int pos;
char *line = NULL;
int status = 0;
reset_tapelist();
if((tapef = fopen(tapefile,"r")) == NULL) {
if (errno == ENOENT) {
/* no tapelist is equivalent to an empty tapelist */
return 0;
} else {
g_debug("Error opening '%s': %s", tapefile, strerror(errno));
return 1;
}
}
while((line = agets(tapef)) != NULL) {
if (line[0] == '\0') {
amfree(line);
continue;
}
tp = parse_tapeline(&status, line);
amfree(line);
if (tp == NULL && status != 0) {
afclose(tapef);
return 1;
}
if (tp != NULL) {
char *tape_key = tape_hash_key(tp->pool, tp->label);
tape_list = insert(tape_list, tp);
g_hash_table_insert(tape_table_storage_label, tape_key, tp);
g_hash_table_insert(tape_table_label, tp->label, tp);
}
}
afclose(tapef);
for(pos=1,tp=tape_list; tp != NULL; pos++,tp=tp->next) {
tp->position = pos;
}
retention_computed = FALSE;
return 0;
}
int fn_Load_Grammar(char *pFile, GRAMMAR * pGr)
{
FILE *file;
char text[256];
file = aopen(b2_2d_font.pArchive, pFile, "rb");
if (!file)
return 0;
pGr->LastMask = 0;
while (!aeof(file)) {
agets(text, 256, file);
gr_Add_Mask(text, pGr);
strcpy(text, "");
}
aclose(file);
return 1;
}
//------------------------------------------------------------------------------------------------
// naparsuje radek animace
//------------------------------------------------------------------------------------------------
void Parse_3DAnimLine(FILE *file, _3D_ANIMATION_FRAME *pFrame)
{
char text[256], expression[256];
int p = 0, r = 0;
agets(text, 256, file);
while(p != -1)
{
p = Find_Next_Expresion(text, p, expression);
if(p != -1)
switch(r)
{
case 1:
pFrame->iTexture = atoi(expression);
break;
case 2:
case 3:
case 4:
case 5:
pFrame->vfLocation[r-2] = (float)atof(expression);
break;
case 6:
pFrame->iTimeToNextFrame = atoi(expression);
break;
case 7:
pFrame->iNextFrame = atoi(expression);
break;
case 8:
pFrame->cCleanDrawLine = (char)atoi(expression);
break;
case 9:
pFrame->fScale = (float)atof(expression);
break;
}
r++;
}
}
void
run_server_script(
pp_script_t *pp_script,
execute_on_t execute_on,
char *config,
disk_t *dp,
int level)
{
pid_t scriptpid;
int scriptin, scriptout, scripterr;
char *cmd;
char *command = NULL;
GPtrArray *argv_ptr = g_ptr_array_new();
FILE *streamout;
char *line;
char *plugin;
char level_number[NUM_STR_SIZE];
if ((pp_script_get_execute_on(pp_script) & execute_on) == 0)
return;
if (pp_script_get_execute_where(pp_script) != ES_SERVER)
return;
plugin = pp_script_get_plugin(pp_script);
cmd = vstralloc(APPLICATION_DIR, "/", plugin, NULL);
g_ptr_array_add(argv_ptr, stralloc(plugin));
switch (execute_on) {
case EXECUTE_ON_PRE_DLE_AMCHECK:
command = "PRE-DLE-AMCHECK";
break;
case EXECUTE_ON_PRE_HOST_AMCHECK:
command = "PRE-HOST-AMCHECK";
break;
case EXECUTE_ON_POST_DLE_AMCHECK:
command = "POST-DLE-AMCHECK";
break;
case EXECUTE_ON_POST_HOST_AMCHECK:
command = "POST-HOST-AMCHECK";
break;
case EXECUTE_ON_PRE_DLE_ESTIMATE:
command = "PRE-DLE-ESTIMATE";
break;
case EXECUTE_ON_PRE_HOST_ESTIMATE:
command = "PRE-HOST-ESTIMATE";
break;
case EXECUTE_ON_POST_DLE_ESTIMATE:
command = "POST-DLE-ESTIMATE";
break;
case EXECUTE_ON_POST_HOST_ESTIMATE:
command = "POST-HOST-ESTIMATE";
break;
case EXECUTE_ON_PRE_DLE_BACKUP:
command = "PRE-DLE-BACKUP";
break;
case EXECUTE_ON_PRE_HOST_BACKUP:
command = "PRE-HOST-BACKUP";
break;
case EXECUTE_ON_POST_DLE_BACKUP:
command = "POST-DLE-BACKUP";
break;
case EXECUTE_ON_POST_HOST_BACKUP:
command = "POST-HOST-BACKUP";
break;
case EXECUTE_ON_PRE_RECOVER:
case EXECUTE_ON_POST_RECOVER:
case EXECUTE_ON_PRE_LEVEL_RECOVER:
case EXECUTE_ON_POST_LEVEL_RECOVER:
case EXECUTE_ON_INTER_LEVEL_RECOVER:
{
// ERROR these script can't be executed on server.
return;
}
}
g_ptr_array_add(argv_ptr, stralloc(command));
g_ptr_array_add(argv_ptr, stralloc("--execute-where"));
g_ptr_array_add(argv_ptr, stralloc("server"));
if (config) {
g_ptr_array_add(argv_ptr, stralloc("--config"));
g_ptr_array_add(argv_ptr, stralloc(config));
}
if (dp->host->hostname) {
g_ptr_array_add(argv_ptr, stralloc("--host"));
g_ptr_array_add(argv_ptr, stralloc(dp->host->hostname));
}
if (dp->name) {
g_ptr_array_add(argv_ptr, stralloc("--disk"));
g_ptr_array_add(argv_ptr, stralloc(dp->name));
}
if (dp->device) {
g_ptr_array_add(argv_ptr, stralloc("--device"));
g_ptr_array_add(argv_ptr, stralloc(dp->device));
}
if (level >= 0) {
g_snprintf(level_number, SIZEOF(level_number), "%d", level);
g_ptr_array_add(argv_ptr, stralloc("--level"));
g_ptr_array_add(argv_ptr, stralloc(level_number));
}
property_add_to_argv(argv_ptr, pp_script_get_property(pp_script));
g_ptr_array_add(argv_ptr, NULL);
scripterr = fileno(stderr);
scriptpid = pipespawnv(cmd, STDIN_PIPE|STDOUT_PIPE, 0, &scriptin,
&scriptout, &scripterr,
(char **)argv_ptr->pdata);
close(scriptin);
streamout = fdopen(scriptout, "r");
if (streamout) {
while((line = agets(streamout)) != NULL) {
dbprintf("script: %s\n", line);
}
}
fclose(streamout);
waitpid(scriptpid, NULL, 0);
g_ptr_array_free_full(argv_ptr);
}
int
start_amandates(
char *amandates_file,
int open_readwrite)
{
int rc, level = 0;
long ldate = 0L;
char *line;
char *name;
char *s;
int ch;
char *qname;
if (amandates_file == NULL) {
errno = 0;
return 0;
}
/* clean up from previous invocation */
if(amdf != NULL)
finish_amandates();
if(amandates_list != NULL)
free_amandates();
amfree(g_amandates_file);
/* initialize state */
updated = 0;
readonly = !open_readwrite;
amdf = NULL;
amandates_list = NULL;
g_amandates_file = g_strdup(amandates_file);
/* open the file */
// if (access(amandates_file,F_OK))
// /* not yet existing */
// if ( (rc = open(amandates_file,(O_CREAT|O_RDWR),0644)) != -1 )
// /* open/create successfull */
// aclose(rc);
if (open_readwrite)
amdf = fopen(amandates_file, "r+");
else
amdf = fopen(amandates_file, "r");
/* create it if we need to */
if (amdf == NULL) {
if (errno == ENOENT) {
amdf = fopen(amandates_file, "w+");
}
}
if (amdf == NULL) {
// errno is set
return 0;
}
if(open_readwrite)
rc = amflock(fileno(amdf), amandates_file);
else
rc = amroflock(fileno(amdf), amandates_file);
if(rc == -1) {
error(_("could not lock %s: %s"), amandates_file, strerror(errno));
/*NOTREACHED*/
}
for(; (line = agets(amdf)) != NULL; free(line)) {
if (line[0] == '\0')
continue;
s = line;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0') {
continue; /* no name field */
}
qname = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0'; /* terminate the name */
name = unquote_string(qname);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf(s - 1, "%d %ld", &level, &ldate) != 2) {
amfree(name);
continue; /* no more fields */
}
if(level < 0 || level >= DUMP_LEVELS) {
amfree(name);
continue;
}
enter_record(name, level, (time_t) ldate);
amfree(name);
}
if(ferror(amdf)) {
error(_("reading %s: %s"), amandates_file, strerror(errno));
/*NOTREACHED*/
}
updated = 0; /* reset updated flag */
return 1;
}
/* Allow the user to select a set of datestamps from those in
* holding disks. The result can be passed to
* holding_get_files_for_flush. If less than two dates are
* available, then no user interaction takes place.
*
* @returns: a new GSList listing the selected datestamps
*/
static GSList *
pick_datestamp(void)
{
GSList *datestamp_list;
GSList *r_datestamp_list = NULL;
GSList *ds;
char **datestamps = NULL;
int i;
char *answer = NULL;
char *a = NULL;
int ch = 0;
char max_char = '\0', chupper = '\0';
datestamp_list = holding_get_all_datestamps();
if(g_slist_length(datestamp_list) < 2) {
return datestamp_list;
} else {
datestamps = g_malloc(g_slist_length(datestamp_list) * sizeof(char *));
for(ds = datestamp_list, i=0; ds != NULL; ds = ds->next,i++) {
datestamps[i] = (char *)ds->data; /* borrowing reference */
}
while(1) {
puts(_("\nMultiple Amanda runs in holding disks; please pick one by letter:"));
for(ds = datestamp_list, max_char = 'A';
ds != NULL && max_char <= 'Z';
ds = ds->next, max_char++) {
g_printf(" %c. %s\n", max_char, (char *)ds->data);
}
max_char--;
g_printf(_("Select datestamps to flush [A..%c or <enter> for all]: "), max_char);
fflush(stdout); fflush(stderr);
amfree(answer);
if ((answer = agets(stdin)) == NULL) {
clearerr(stdin);
continue;
}
if (*answer == '\0' || strncasecmp(answer, "ALL", 3) == 0) {
break;
}
a = answer;
while ((ch = *a++) != '\0') {
if (!g_ascii_isspace(ch))
break;
}
/* rewrite the selected list into r_datestamp_list, then copy it over
* to datestamp_list */
do {
if (g_ascii_isspace(ch) || ch == ',') {
continue;
}
chupper = (char)toupper(ch);
if (chupper < 'A' || chupper > max_char) {
slist_free_full(r_datestamp_list, g_free);
r_datestamp_list = NULL;
break;
}
r_datestamp_list = g_slist_append(r_datestamp_list,
g_strdup(datestamps[chupper - 'A']));
} while ((ch = *a++) != '\0');
if (r_datestamp_list && ch == '\0') {
slist_free_full(datestamp_list, g_free);
datestamp_list = r_datestamp_list;
break;
}
}
}
amfree(datestamps); /* references in this array are borrowed */
amfree(answer);
return datestamp_list;
}
int cr_CreditsUNI(HWND hWnd, AUDIO_DATA * p_ad)
{
DWORD dwStart, dwStop, dwEplased = 0;
int y = 868;
int dy = 868*2 + 2000;
char text[256];
char cbmp[256];
FILE *file;
int c = 0;
int bmp = 0;
RECT r;
float f = p_ad->Music_Gain;
int i;
CREDIT_SURFACE cs[CREDIT_SURFACES];
int iActual = 0;
int iClock[12];
APAK_HANDLE *hArchive = NULL;
int error;
for(i=0;i<12;i++)
iClock[i] = -1;
LoadClock(iClock);
if(iClock[0] != -1)
{
ddxResizeCursorBack(iClock[0]);
DrawClock(iClock, 0);
}
if(ogg_playing())
{
while(f >= 0.05f)
{
f -= 0.05f;
ogg_gain(f);
Sleep(25);
DrawClock(iClock, 0);
}
ap_Stop_Song(p_ad);
}
for(i=0;i<CREDIT_SURFACES;i++)
{
cs[i].iSurface = -1;
cs[i].x = 0;
cs[i].y = 0;
}
strcpy(text,BITMAP_DIR);
chdir(text);
hArchive = apakopen(cFontFile[2], text, &error);
if(!hArchive)
return 0;
else
hArchive->pActualNode = hArchive->pRootNode->pNextNode;
file = aopen(hArchive, "credits.txt", "r");
if(!file)
return 0;
aunicode(file);
while(!aeof(file))
{
agets(text, 256, file);
c++;
}
DrawClock(iClock, 1);
aseek(file, 2, SEEK_SET);
dy += c * 75;
if(c > CREDIT_SURFACES-1)
{
kprintf(1, "Kredity: radku je vic jak surfacu!");
apakclose(&hArchive);
return 0;
}
ddxSetFlip(0);
fn_Set_Font(cFontFile[0]);
DrawClock(iClock, 2);
fn_Load_Bitmaps();
DrawClock(iClock, 3);
cs[iActual].iSurface = ddxLoadBitmap("anakreon_small.bmp", pBmpArchive);
if(cs[iActual].iSurface == -1)
{
cr_Release_Bitmaps(cs, iClock);
apakclose(&hArchive);
return 0;
}
else
cr_Set_Surface(&cs[iActual], y);
DrawClock(iClock, 4);
y+= 250;
iActual++;
cs[iActual].iSurface = ddxLoadBitmap("cinemax_small.bmp", pBmpArchive);
if(cs[iActual].iSurface == -1)
{
cr_Release_Bitmaps(cs, iClock);
apakclose(&hArchive);
return 0;
}
else
cr_Set_Surface(&cs[iActual], y);
iActual++;
y+= 768;
DrawClock(iClock, 5);
r.left = 0;
r.right = 1024;
r.top = 0;
r.bottom = 90;
while(!aeof(file))
{
ZeroMemory(text, 256);
agets(text, 256, file);
if(text[0] == '$')
{
if(bmp < 5)
{
if(bmp)
{
sprintf(cbmp, "brouk%d.bmp", bmp);
cs[iActual].iSurface = ddxLoadBitmap(cbmp, pBmpArchive);
if(cs[iActual].iSurface == -1)
{
cr_Release_Bitmaps(cs, iClock);
apakclose(&hArchive);
return 0;
}
else
{
cr_Set_Surface(&cs[iActual], y);
y += ddxGetHight(cs[iActual].iSurface);
iActual++;
}
}
bmp++;
}
cs[iActual].iSurface = ddxCreateSurface(1024, 90, ddxFindFreeSurface());
if(cs[iActual].iSurface == -1)
{
cr_Release_Bitmaps(cs, iClock);
apakclose(&hArchive);
return 0;
}
else
{
ddxCleareSurfaceColor(cs[iActual].iSurface, 0);
cr_Set_Text_CenterW(cs[iActual].iSurface, (WCHAR *)text, 1, r);
cs[iActual].y = y;
iActual++;
}
}
else
if(strcmp(text,"\n") && strlen(text))
{
cs[iActual].iSurface = ddxCreateSurface(1024, 90, ddxFindFreeSurface());
if(cs[iActual].iSurface == -1)
{
cr_Release_Bitmaps(cs, iClock);
apakclose(&hArchive);
return 0;
}
else
{
ddxCleareSurfaceColor(cs[iActual].iSurface, 0);
cr_Set_Text_CenterW(cs[iActual].iSurface, (WCHAR *)text, 0, r);
cs[iActual].y = y;
iActual++;
}
}
y += 80;
if(iActual >= CREDIT_SURFACES)
{
kprintf(1, "iActual >= CREDIT_SURFACES !!!!!!!!!!!");
break;
}
DrawClock(iClock, 6);
}
aclose(file);
y = 0;
ap_Play_Song(11,0, p_ad);
ddxResizeCursorBack(0);
ddxSetCursorSurface(0);
for(i=0;i<12;i++)
if(iClock[i] != -1)
{
ddxReleaseBitmap(iClock[i]);
iClock[i] = -1;
}
ddxSetCursor(0);
dwStart = timeGetTime();
while(!key[K_ESC])
{
y = (int)ftoi((dwEplased * dy) / (float) 195000);
if(y >= dy)
key[K_ESC] = 1;
cr_Draw_Creadits(cs, y);
dwStop = timeGetTime();
dwEplased = dwStop - dwStart;
ddxRestore(p_ad);
}
cr_Release_Bitmaps(cs, iClock);
fn_Release_Font(1);
if(ogg_playing())
ap_Stop_Song(p_ad);
//Sleep(1000);
ap_Play_Song(0, 0, p_ad);
ddxSetCursor(1);
ddxSetFlip(1);
key[K_ESC] = 0;
apakclose(&hArchive);
return 0;
}
char *
get_first_line(
GPtrArray *argv_ptr)
{
char *output_string = NULL;
int inpipe[2], outpipe[2], errpipe[2];
int pid;
FILE *out, *err;
assert(argv_ptr != NULL);
assert(argv_ptr->pdata != NULL);
assert(argv_ptr->len >= 1);
if (pipe(inpipe) == -1) {
error(_("error [open pipe: %s]"), strerror(errno));
/*NOTREACHED*/
}
if (pipe(outpipe) == -1) {
error(_("error [open pipe: %s]"), strerror(errno));
/*NOTREACHED*/
}
if (pipe(errpipe) == -1) {
error(_("error [open pipe: %s]"), strerror(errno));
/*NOTREACHED*/
}
fflush(stdout);
switch(pid = fork()) {
case -1:
error(_("error [fork: %s]"), strerror(errno));
/*NOTREACHED*/
default: /* parent process */
aclose(inpipe[0]);
aclose(outpipe[1]);
aclose(errpipe[1]);
break;
case 0: /* child process */
aclose(inpipe[1]);
aclose(outpipe[0]);
aclose(errpipe[0]);
dup2(inpipe[0], 0);
dup2(outpipe[1], 1);
dup2(errpipe[1], 2);
debug_executing(argv_ptr);
g_fprintf(stdout, "unknown\n");
execv((char *)*argv_ptr->pdata, (char **)argv_ptr->pdata);
error(_("error [exec %s: %s]"), (char *)*argv_ptr->pdata, strerror(errno));
}
aclose(inpipe[1]);
out = fdopen(outpipe[0],"r");
err = fdopen(errpipe[0],"r");
if (out) {
output_string = agets(out);
fclose(out);
}
if (err) {
if (!output_string)
output_string = agets(err);
fclose(err);
}
waitpid(pid, NULL, 0);
return output_string;
}
void _3d_Load_Animations(float *fScaleFactor)
{
_3D_ANIMATION_FRAME *pFrame;
_3D_ANIMATION *p3DAnim;
FILE *pFile = NULL, *pListFile = NULL;
char text[256];
int i = 0, j;
GetPrivateProfileString("game","data_dir","c:\\",text,256,ini_file);
achdir(pDataArchive, text);
pListFile = aopen(pDataArchive, "3DAnimations.dat","r");
if(pListFile)
{
while(!aeof(pListFile))
{
agets(text,256,pListFile);
if(!strlen(text))
break;
else
text[strlen(text)-1] = '\0';
pFile = aopen(pDataArchive, text,"r");
if(pFile)
{
p3DAnim = &_3DAnimationStruct._3DAnimation[i];
j = 0;
while(!aeof(pFile))
{
pFrame = &p3DAnim->_3dFrame[j];
Parse_3DAnimLine(pFile, pFrame);
if(i >= 16 && i < 23)
{
float dx;
pFrame->iTexture += MENU_ANIMATION_CORECTION;
dx = ((pFrame->vfLocation[2] - pFrame->vfLocation[0]) - (_3dd.p_sysramtexture[pFrame->iTexture].tx * pFrame->fScale)) / 2.0f;
pFrame->vfLocation[0] += dx;
pFrame->vfLocation[2] = pFrame->vfLocation[0] + (_3dd.p_sysramtexture[pFrame->iTexture].x * pFrame->fScale);
pFrame->vfLocation[3] = pFrame->vfLocation[1] + _3dd.p_sysramtexture[pFrame->iTexture].y * pFrame->fScale;
pFrame->vfLocation[0] *= fScaleFactor[0];
pFrame->vfLocation[1] *= fScaleFactor[1];
pFrame->vfLocation[2] *= fScaleFactor[0];
pFrame->vfLocation[3] *= fScaleFactor[1];
}
else
{
pFrame->vfLocation[0] *= fScaleFactor[0];
pFrame->vfLocation[1] *= fScaleFactor[1];
pFrame->vfLocation[2] *= fScaleFactor[0];
pFrame->vfLocation[3] *= fScaleFactor[1];
}
j++;
}
p3DAnim->bStop = 0;
p3DAnim->iActFrame = 0;
p3DAnim->iLastFrame = j - 1;
p3DAnim->iID = i;
i++;
aclose(pFile);
strcpy(text,"");
}
else
kprintf(1,"Nenalezen 3danimacni soubor %s", text);
}
_3d_Add_To_OpenMenuAnim(&_3DAnimationStruct._3DAnimation[14]);
aclose(pListFile);
}
else
{
//MessageBox(NULL,"Nenalezen soubor se seznamem 3d animaci!","Chyba", MB_OK);
kprintf(1,"Nenalezen soubor se seznamem 3d animaci!");
}
_3DAnimationStruct.pFDrawList = NULL;
_3DAnimationStruct.pLDrawList = NULL;
_3DAnimationStruct.pFAnimation = NULL;
_3DAnimationStruct.pLAnimation = NULL;
_3DAnimationStruct.bMenuButton = 0;
_3DAnimationStruct.bItem = 0;
_3DAnimationStruct.iItemID = -1;
_3DAnimationStruct.iItemIndex = -1;
_3DAnimationStruct.iInvIndex = -1;
_3DAnimationStruct.iCibuleID = -1;
_3DAnimationStruct.bLastMenuItem = 0;
_3DAnimationStruct.iLastMenuItemID = -1;
_3DAnimationStruct.iLastIsIn = -1;
}
int
main(
int argc,
char ** argv)
{
int interactive = 0;
int level = 0;
int mesgpipe[2];
dle_t *dle = NULL;
char *dumpdate, *stroptions;
char *qdisk = NULL;
char *qamdevice = NULL;
char *line = NULL;
char *err_extra = NULL;
char *s;
int i;
int ch;
GSList *errlist;
FILE *mesgstream;
level_t *alevel;
/* initialize */
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(DATA_FD_OFFSET, DATA_FD_COUNT*2);
safe_cd();
set_pname("sendbackup");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
/* Don't die when interrupt received */
signal(SIGINT, SIG_IGN);
if(argc > 1 && strcmp(argv[1],"-t") == 0) {
interactive = 1;
argc--;
argv++;
} else {
interactive = 0;
}
erroutput_type = (ERR_INTERACTIVE|ERR_SYSLOG);
dbopen(DBG_SUBDIR_CLIENT);
startclock();
dbprintf(_("Version %s\n"), version());
if(argc > 2 && strcmp(argv[1], "amandad") == 0) {
amandad_auth = stralloc(argv[2]);
}
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
config_init(CONFIG_INIT_CLIENT, NULL);
/* (check for config errors comes later) */
check_running_as(RUNNING_AS_CLIENT_LOGIN);
if(interactive) {
/*
* In interactive (debug) mode, the backup data is sent to
* /dev/null and none of the network connections back to driver
* programs on the tape host are set up. The index service is
* run and goes to stdout.
*/
g_fprintf(stderr, _("%s: running in interactive test mode\n"), get_pname());
fflush(stderr);
}
qdisk = NULL;
dumpdate = NULL;
stroptions = NULL;
for(; (line = agets(stdin)) != NULL; free(line)) {
if (line[0] == '\0')
continue;
if(interactive) {
g_fprintf(stderr, "%s> ", get_pname());
fflush(stderr);
}
if(strncmp_const(line, "OPTIONS ") == 0) {
g_options = parse_g_options(line+8, 1);
if(!g_options->hostname) {
g_options->hostname = alloc(MAX_HOSTNAME_LENGTH+1);
gethostname(g_options->hostname, MAX_HOSTNAME_LENGTH);
g_options->hostname[MAX_HOSTNAME_LENGTH] = '\0';
}
if (g_options->config) {
/* overlay this configuration on the existing (nameless) configuration */
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY,
g_options->config);
dbrename(get_config_name(), DBG_SUBDIR_CLIENT);
}
/* check for any config errors now */
if (config_errors(&errlist) >= CFGERR_ERRORS) {
char *errstr = config_errors_to_error_string(errlist);
g_printf("%s\n", errstr);
dbclose();
return 1;
}
if (am_has_feature(g_options->features, fe_req_xml)) {
break;
}
continue;
}
if (dle && dle->program != NULL) {
err_extra = _("multiple requests");
goto err;
}
dbprintf(_(" sendbackup req: <%s>\n"), line);
dle = alloc_dle();
s = line;
ch = *s++;
skip_whitespace(s, ch); /* find the program name */
if(ch == '\0') {
err_extra = _("no program name");
goto err; /* no program name */
}
dle->program = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (strcmp(dle->program, "APPLICATION")==0) {
dle->program_is_application_api=1;
skip_whitespace(s, ch); /* find dumper name */
if (ch == '\0') {
goto err; /* no program */
}
dle->program = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
}
dle->program = stralloc(dle->program);
skip_whitespace(s, ch); /* find the disk name */
if(ch == '\0') {
err_extra = _("no disk name");
goto err; /* no disk name */
}
amfree(qdisk);
qdisk = s - 1;
ch = *qdisk;
skip_quoted_string(s, ch);
s[-1] = '\0';
qdisk = stralloc(qdisk);
dle->disk = unquote_string(qdisk);
skip_whitespace(s, ch); /* find the device or level */
if (ch == '\0') {
err_extra = _("bad level");
goto err;
}
if(!isdigit((int)s[-1])) {
amfree(qamdevice);
qamdevice = s - 1;
ch = *qamdevice;
skip_quoted_string(s, ch);
s[-1] = '\0';
qamdevice = stralloc(qamdevice);
dle->device = unquote_string(qamdevice);
skip_whitespace(s, ch); /* find level number */
}
else {
dle->device = stralloc(dle->disk);
qamdevice = stralloc(qdisk);
}
/* find the level number */
if(ch == '\0' || sscanf(s - 1, "%d", &level) != 1) {
err_extra = _("bad level");
goto err; /* bad level */
}
skip_integer(s, ch);
alevel = g_new0(level_t, 1);
alevel->level = level;
dle->levellist = g_slist_append(dle->levellist, alevel);
skip_whitespace(s, ch); /* find the dump date */
if(ch == '\0') {
err_extra = _("no dumpdate");
goto err; /* no dumpdate */
}
amfree(dumpdate);
dumpdate = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
dumpdate = stralloc(dumpdate);
skip_whitespace(s, ch); /* find the options keyword */
if(ch == '\0') {
err_extra = _("no options");
goto err; /* no options */
}
if(strncmp_const_skip(s - 1, "OPTIONS ", s, ch) != 0) {
err_extra = _("no OPTIONS keyword");
goto err; /* no options */
}
skip_whitespace(s, ch); /* find the options string */
if(ch == '\0') {
err_extra = _("bad options string");
goto err; /* no options */
}
amfree(stroptions);
stroptions = stralloc(s - 1);
}
amfree(line);
if (g_options == NULL) {
g_printf(_("ERROR [Missing OPTIONS line in sendbackup input]\n"));
error(_("Missing OPTIONS line in sendbackup input\n"));
/*NOTREACHED*/
}
if (am_has_feature(g_options->features, fe_req_xml)) {
char *errmsg = NULL;
dle = amxml_parse_node_FILE(stdin, &errmsg);
if (errmsg) {
err_extra = errmsg;
goto err;
}
if (!dle) {
err_extra = _("One DLE required");
goto err;
} else if (dle->next) {
err_extra = _("Only one DLE allowed");
goto err;
}
qdisk = quote_string(dle->disk);
if (dle->device == NULL)
dle->device = stralloc(dle->disk);
qamdevice = quote_string(dle->device);
dumpdate = stralloc("NODATE");
stroptions = stralloc("");
} else {
parse_options(stroptions, dle, g_options->features, 0);
}
gdle = dle;
if (dle->program == NULL ||
dle->disk == NULL ||
dle->device == NULL ||
dle->levellist == NULL ||
dumpdate == NULL) {
err_extra = _("no valid sendbackup request");
goto err;
}
if (g_slist_length(dle->levellist) != 1) {
err_extra = _("Too many level");
goto err;
}
alevel = (level_t *)dle->levellist->data;
level = alevel->level;
dbprintf(_(" Parsed request as: program `%s'\n"), dle->program);
dbprintf(_(" disk `%s'\n"), qdisk);
dbprintf(_(" device `%s'\n"), qamdevice);
dbprintf(_(" level %d\n"), level);
dbprintf(_(" since %s\n"), dumpdate);
dbprintf(_(" options `%s'\n"), stroptions);
if (dle->program_is_application_api==1) {
/* check that the application_api exist */
} else {
for(i = 0; programs[i]; i++) {
if (strcmp(programs[i]->name, dle->program) == 0) {
break;
}
}
if (programs[i] == NULL) {
dbprintf(_("ERROR [%s: unknown program %s]\n"), get_pname(),
dle->program);
error(_("ERROR [%s: unknown program %s]"), get_pname(),
dle->program);
/*NOTREACHED*/
}
program = programs[i];
}
if(!interactive) {
datafd = DATA_FD_OFFSET + 0;
mesgfd = DATA_FD_OFFSET + 2;
indexfd = DATA_FD_OFFSET + 4;
}
if (!dle->create_index)
indexfd = -1;
if (dle->auth && amandad_auth) {
if(strcasecmp(dle->auth, amandad_auth) != 0) {
g_printf(_("ERROR [client configured for auth=%s while server requested '%s']\n"),
amandad_auth, dle->auth);
exit(-1);
}
}
if (dle->kencrypt) {
g_printf("KENCRYPT\n");
}
g_printf(_("CONNECT DATA %d MESG %d INDEX %d\n"),
DATA_FD_OFFSET, DATA_FD_OFFSET+1,
indexfd == -1 ? -1 : DATA_FD_OFFSET+2);
g_printf(_("OPTIONS "));
if(am_has_feature(g_options->features, fe_rep_options_features)) {
g_printf("features=%s;", our_feature_string);
}
if(am_has_feature(g_options->features, fe_rep_options_hostname)) {
g_printf("hostname=%s;", g_options->hostname);
}
g_printf("\n");
fflush(stdout);
if (freopen("/dev/null", "w", stdout) == NULL) {
dbprintf(_("Error redirecting stdout to /dev/null: %s\n"),
strerror(errno));
exit(1);
}
if(interactive) {
if((datafd = open("/dev/null", O_RDWR)) < 0) {
error(_("ERROR [open of /dev/null for debug data stream: %s]\n"),
strerror(errno));
/*NOTREACHED*/
}
mesgfd = 2;
indexfd = 1;
}
if(!interactive) {
if(datafd == -1 || mesgfd == -1 || (dle->create_index && indexfd == -1)) {
dbclose();
exit(1);
}
}
mesgstream = fdopen(mesgfd,"w");
run_client_scripts(EXECUTE_ON_PRE_DLE_BACKUP, g_options, dle, mesgstream);
fflush(mesgstream);
if (dle->program_is_application_api==1) {
guint j;
char *cmd=NULL;
GPtrArray *argv_ptr;
char levelstr[20];
backup_support_option_t *bsu;
char *compopt = NULL;
char *encryptopt = skip_argument;
int compout, dumpout;
GSList *scriptlist;
script_t *script;
time_t cur_dumptime;
int result;
GPtrArray *errarray;
int errfd[2];
FILE *dumperr;
/* apply client-side encryption here */
if ( dle->encrypt == ENCRYPT_CUST ) {
encpid = pipespawn(dle->clnt_encrypt, STDIN_PIPE, 0,
&compout, &datafd, &mesgfd,
dle->clnt_encrypt, encryptopt, NULL);
dbprintf(_("encrypt: pid %ld: %s\n"), (long)encpid, dle->clnt_encrypt);
} else {
compout = datafd;
encpid = -1;
}
/* now do the client-side compression */
if(dle->compress == COMP_FAST || dle->compress == COMP_BEST) {
compopt = skip_argument;
#if defined(COMPRESS_BEST_OPT) && defined(COMPRESS_FAST_OPT)
if(dle->compress == COMP_BEST) {
compopt = COMPRESS_BEST_OPT;
} else {
compopt = COMPRESS_FAST_OPT;
}
#endif
comppid = pipespawn(COMPRESS_PATH, STDIN_PIPE, 0,
&dumpout, &compout, &mesgfd,
COMPRESS_PATH, compopt, NULL);
dbprintf(_("gnutar: pid %ld: %s"), (long)comppid, COMPRESS_PATH);
if(compopt != skip_argument) {
dbprintf(_("pid %ld: %s %s\n"),
(long)comppid, COMPRESS_PATH, compopt);
} else {
dbprintf(_("pid %ld: %s\n"), (long)comppid, COMPRESS_PATH);
}
} else if (dle->compress == COMP_CUST) {
compopt = skip_argument;
comppid = pipespawn(dle->compprog, STDIN_PIPE, 0,
&dumpout, &compout, &mesgfd,
dle->compprog, compopt, NULL);
if(compopt != skip_argument) {
dbprintf(_("pid %ld: %s %s\n"),
(long)comppid, dle->compprog, compopt);
} else {
dbprintf(_("pid %ld: %s\n"), (long)comppid, dle->compprog);
}
} else {
dumpout = compout;
comppid = -1;
}
cur_dumptime = time(0);
bsu = backup_support_option(dle->program, g_options, dle->disk,
dle->device, &errarray);
if (!bsu) {
char *errmsg;
char *qerrmsg;
guint i;
for (i=0; i < errarray->len; i++) {
errmsg = g_ptr_array_index(errarray, i);
qerrmsg = quote_string(errmsg);
fdprintf(mesgfd,
_("sendbackup: error [Application '%s': %s]\n"),
dle->program, errmsg);
dbprintf("aa: %s\n",qerrmsg);
amfree(qerrmsg);
}
if (i == 0) { /* no errarray */
errmsg = vstrallocf(_("Can't execute application '%s'"),
dle->program);
qerrmsg = quote_string(errmsg);
fdprintf(mesgfd, _("sendbackup: error [%s]\n"), errmsg);
dbprintf(_("ERROR %s\n"), qerrmsg);
amfree(qerrmsg);
amfree(errmsg);
}
return 0;
}
if (pipe(errfd) < 0) {
char *errmsg;
char *qerrmsg;
errmsg = vstrallocf(_("Application '%s': can't create pipe"),
dle->program);
qerrmsg = quote_string(errmsg);
fdprintf(mesgfd, _("sendbackup: error [%s]\n"), errmsg);
dbprintf(_("ERROR %s\n"), qerrmsg);
amfree(qerrmsg);
amfree(errmsg);
return 0;
}
switch(application_api_pid=fork()) {
case 0:
argv_ptr = g_ptr_array_new();
cmd = vstralloc(APPLICATION_DIR, "/", dle->program, NULL);
g_ptr_array_add(argv_ptr, stralloc(dle->program));
g_ptr_array_add(argv_ptr, stralloc("backup"));
if (bsu->message_line == 1) {
g_ptr_array_add(argv_ptr, stralloc("--message"));
g_ptr_array_add(argv_ptr, stralloc("line"));
}
if (g_options->config && bsu->config == 1) {
g_ptr_array_add(argv_ptr, stralloc("--config"));
g_ptr_array_add(argv_ptr, stralloc(g_options->config));
}
if (g_options->hostname && bsu->host == 1) {
g_ptr_array_add(argv_ptr, stralloc("--host"));
g_ptr_array_add(argv_ptr, stralloc(g_options->hostname));
}
if (dle->disk && bsu->disk == 1) {
g_ptr_array_add(argv_ptr, stralloc("--disk"));
g_ptr_array_add(argv_ptr, stralloc(dle->disk));
}
g_ptr_array_add(argv_ptr, stralloc("--device"));
g_ptr_array_add(argv_ptr, stralloc(dle->device));
if (level <= bsu->max_level) {
g_ptr_array_add(argv_ptr, stralloc("--level"));
g_snprintf(levelstr,19,"%d",level);
g_ptr_array_add(argv_ptr, stralloc(levelstr));
}
if (indexfd != -1 && bsu->index_line == 1) {
g_ptr_array_add(argv_ptr, stralloc("--index"));
g_ptr_array_add(argv_ptr, stralloc("line"));
}
if (dle->record && bsu->record == 1) {
g_ptr_array_add(argv_ptr, stralloc("--record"));
}
application_property_add_to_argv(argv_ptr, dle, bsu);
for (scriptlist = dle->scriptlist; scriptlist != NULL;
scriptlist = scriptlist->next) {
script = (script_t *)scriptlist->data;
if (script->result && script->result->proplist) {
property_add_to_argv(argv_ptr, script->result->proplist);
}
}
g_ptr_array_add(argv_ptr, NULL);
dbprintf(_("%s: running \"%s\n"), get_pname(), cmd);
for (j = 1; j < argv_ptr->len - 1; j++)
dbprintf(" %s\n", (char *)g_ptr_array_index(argv_ptr,j));
dbprintf(_("\"\n"));
if(dup2(dumpout, 1) == -1) {
error(_("Can't dup2: %s"),strerror(errno));
/*NOTREACHED*/
}
if (dup2(errfd[1], 2) == -1) {
error(_("Can't dup2: %s"),strerror(errno));
/*NOTREACHED*/
}
if(dup2(mesgfd, 3) == -1) {
error(_("Can't dup2: %s"),strerror(errno));
/*NOTREACHED*/
}
if(indexfd > 0) {
if(dup2(indexfd, 4) == -1) {
error(_("Can't dup2: %s"),strerror(errno));
/*NOTREACHED*/
}
fcntl(indexfd, F_SETFD, 0);
}
application_api_info_tapeheader(mesgfd, dle->program, dle);
if (indexfd != 0) {
safe_fd(3, 2);
} else {
safe_fd(3, 1);
}
execve(cmd, (char **)argv_ptr->pdata, safe_env());
exit(1);
break;
default:
break;
case -1:
error(_("%s: fork returned: %s"), get_pname(), strerror(errno));
}
close(errfd[1]);
dumperr = fdopen(errfd[0],"r");
if (!dumperr) {
error(_("Can't fdopen: %s"), strerror(errno));
/*NOTREACHED*/
}
result = 0;
while ((line = agets(dumperr)) != NULL) {
if (strlen(line) > 0) {
fdprintf(mesgfd, "sendbackup: error [%s]\n", line);
dbprintf("error: %s\n", line);
result = 1;
}
amfree(line);
}
result |= check_result(mesgfd);
if (result == 0) {
char *amandates_file;
amandates_file = getconf_str(CNF_AMANDATES);
if(start_amandates(amandates_file, 1)) {
amandates_updateone(dle->disk, level, cur_dumptime);
finish_amandates();
free_amandates();
} else {
if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE &&
bsu->calcsize) {
error(_("error [opening %s for writing: %s]"),
amandates_file, strerror(errno));
} else {
g_debug(_("non-fatal error opening '%s' for writing: %s]"),
amandates_file, strerror(errno));
}
}
}
amfree(bsu);
} else {
if(!interactive) {
/* redirect stderr */
if(dup2(mesgfd, 2) == -1) {
dbprintf(_("Error redirecting stderr to fd %d: %s\n"),
mesgfd, strerror(errno));
dbclose();
exit(1);
}
}
if(pipe(mesgpipe) == -1) {
s = strerror(errno);
dbprintf(_("error [opening mesg pipe: %s]\n"), s);
error(_("error [opening mesg pipe: %s]"), s);
}
program->start_backup(dle, g_options->hostname,
datafd, mesgpipe[1], indexfd);
dbprintf(_("Started backup\n"));
parse_backup_messages(dle, mesgpipe[0]);
dbprintf(_("Parsed backup messages\n"));
}
run_client_scripts(EXECUTE_ON_POST_DLE_BACKUP, g_options, dle, mesgstream);
fflush(mesgstream);
amfree(qdisk);
amfree(qamdevice);
amfree(dumpdate);
amfree(stroptions);
amfree(our_feature_string);
am_release_feature_set(our_features);
our_features = NULL;
free_g_options(g_options);
dbclose();
return 0;
err:
if (err_extra) {
g_printf(_("ERROR FORMAT ERROR IN REQUEST PACKET '%s'\n"), err_extra);
dbprintf(_("REQ packet is bogus: %s\n"), err_extra);
} else {
g_printf(_("ERROR FORMAT ERROR IN REQUEST PACKET\n"));
dbprintf(_("REQ packet is bogus\n"));
}
amfree(qdisk);
amfree(qamdevice);
amfree(dumpdate);
amfree(stroptions);
amfree(our_feature_string);
dbclose();
return 1;
}
/*
* This function reads the specified configfile and fills the structure
*/
int
read_config(
char * configfile,
changer_t * chg)
{
size_t numconf;
FILE *file;
int init_flag = 0;
size_t drivenum=0;
char *linebuffer;
int token;
char *value;
numconf = 1; /* At least one configuration is assumed */
/* If there are more, it should be the first entry in the configurationfile */
if (NULL==(file=fopen(configfile,"r"))){
return (-1);
}
while (NULL != (linebuffer = agets(file))) {
if (linebuffer[0] == '\0') {
amfree(linebuffer);
continue;
}
parse_line(linebuffer,&token,&value);
if (token != -1){
if (0==init_flag) {
if (token != NUMDRIVE){
init_changer_struct(chg, numconf);
} else {
numconf = atoi(value);
init_changer_struct(chg, numconf);
}
init_flag=1;
}
switch (token){
case NUMDRIVE: if ((size_t)atoi(value) != numconf)
g_fprintf(stderr,_("Error: number_drives at wrong place, should be "
"first in file\n"));
break;
case EJECT:
chg->eject = atoi(value);
break;
case SLEEP:
chg->sleep = atoi(value);
break;
case CHANGERDEV:
chg->device = stralloc(value);
break;
case SCSITAPEDEV:
chg->conf[drivenum].scsitapedev = stralloc(value);
break;
case TAPESTATFILE:
chg->conf[drivenum].tapestatfile = stralloc(value);
break;
case CLEANMAX:
chg->cleanmax = atoi(value);
break;
case DRIVE:
drivenum = atoi(value);
if(drivenum >= numconf){
g_fprintf(stderr,_("Error: drive must be less than number_drives\n"));
}
break;
case DRIVENUM:
if (drivenum < numconf){
chg->conf[drivenum].drivenum = atoi(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" drivenum ignored\n"));
}
break;
case START:
if (drivenum < numconf){
chg->conf[drivenum].start = atoi(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" startuse ignored\n"));
}
break;
case END:
if (drivenum < numconf){
chg->conf[drivenum].end = atoi(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" enduse ignored\n"));
}
break;
case CLEAN:
if (drivenum < numconf){
chg->conf[drivenum].cleanslot = atoi(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" cleanslot ignored\n"));
}
break;
case DEVICE:
if (drivenum < numconf){
chg->conf[drivenum].device = stralloc(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" device ignored\n"));
}
break;
case STATFILE:
if (drivenum < numconf){
chg->conf[drivenum].slotfile = stralloc(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" slotfile ignored\n"));
}
break;
case CLEANFILE:
if (drivenum < numconf){
chg->conf[drivenum].cleanfile = stralloc(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" cleanfile ignored\n"));
}
break;
case USAGECOUNT:
if (drivenum < numconf){
chg->conf[drivenum].timefile = stralloc(value);
} else {
g_fprintf(stderr,_("Error: drive is not less than number_drives"
" usagecount ignored\n"));
}
break;
default:
g_fprintf(stderr,_("Error: Unknown token\n"));
break;
}
}
amfree(linebuffer);
}
amfree(linebuffer);
fclose(file);
return 0;
}
/* XXX - code assumes AVG_COUNT == 3 */
static int
read_txinfofile(
FILE * infof,
info_t * info)
{
char *line = NULL;
int version;
int rc;
perf_t *pp;
char *s;
int ch;
int nb_history;
int i;
/* get version: command: lines */
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, _("version: %d"), &version);
amfree(line);
if(rc != 1) return -2;
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, _("command: %u"), &info->command);
amfree(line);
if(rc != 1) return -2;
/* get rate: and comp: lines for full dumps */
pp = &info->full;
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, "full-rate: %lf %lf %lf",
&pp->rate[0], &pp->rate[1], &pp->rate[2]);
amfree(line);
if(rc > 3) return -2;
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, "full-comp: %lf %lf %lf",
&pp->comp[0], &pp->comp[1], &pp->comp[2]);
amfree(line);
if(rc > 3) return -2;
/* get rate: and comp: lines for incr dumps */
pp = &info->incr;
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, "incr-rate: %lf %lf %lf",
&pp->rate[0], &pp->rate[1], &pp->rate[2]);
amfree(line);
if(rc > 3) return -2;
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
rc = sscanf(line, "incr-comp: %lf %lf %lf",
&pp->comp[0], &pp->comp[1], &pp->comp[2]);
amfree(line);
if(rc > 3) return -2;
/* get stats for dump levels */
for(rc = -2; (line = agets(infof)) != NULL; free(line)) {
stats_t onestat; /* one stat record */
int level = 0;
long long off_t_tmp;
if (line[0] == '\0')
continue;
if(line[0] == '/' && line[1] == '/') {
rc = 0;
amfree(line);
return 0; /* normal end of record */
}
else if (strncmp_const(line,"last_level:") == 0) {
break; /* normal */
}
else if (strncmp_const(line,"history:") == 0) {
break; /* normal */
}
memset(&onestat, 0, sizeof(onestat));
s = line;
ch = *s++;
/* from here on, we had better be parsing a 'stats' line */
if(strncmp_const_skip(line, "stats:", s, ch) != 0) {
amfree(line);
return -1;
}
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%d", &level) != 1) {
amfree(line);
return -1;
}
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
return -1;
}
onestat.size = (off_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
return -1;
}
onestat.csize = (off_t)off_t_tmp;
skip_integer(s, ch);
/* assume that the time fits in a long long */
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
return -1;
}
onestat.secs = (time_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
return -1;
}
onestat.date = (time_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch != '\0') {
if(sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
return -1;
}
onestat.filenum = (off_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0') {
amfree(line);
return -1;
}
strncpy(onestat.label, s-1, sizeof(onestat.label)-1);
onestat.label[sizeof(onestat.label)-1] = '\0';
}
if (level < 0 || level > DUMP_LEVELS-1) {
amfree(line);
return -1;
}
info->inf[level] = onestat;
}
if(line == NULL) return -1;
rc = sscanf(line, "last_level: %d %d",
&info->last_level, &info->consecutive_runs);
amfree(line);
if(rc > 2) return -2;
rc = 0;
nb_history = 0;
for(i=0;i<=NB_HISTORY;i++) {
info->history[i].level = -2;
}
for(rc = -2; (line = agets(infof)) != NULL; free(line)) {
history_t onehistory; /* one history record */
long long off_t_tmp;
if (line[0] == '\0')
continue;
if(line[0] == '/' && line[1] == '/') {
info->history[nb_history].level = -2;
rc = 0;
amfree(line);
return 0; /* normal end of record */
}
memset(&onehistory, 0, sizeof(onehistory));
s = line;
ch = *s++;
if(strncmp_const_skip(line, "history:", s, ch) != 0) {
amfree(line);
break;
}
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%d", &onehistory.level) != 1) {
amfree(line);
break;
}
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
break;
}
onehistory.size = (off_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
break;
}
onehistory.csize = (off_t)off_t_tmp;
skip_integer(s, ch);
skip_whitespace(s, ch);
if(ch == '\0' || sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
break;
}
onehistory.date = (time_t)off_t_tmp;
skip_integer(s, ch);
onehistory.secs = (unsigned long)-1;
skip_whitespace(s, ch);
if(ch != '\0') {
if(sscanf((s - 1), "%lld", &off_t_tmp) != 1) {
amfree(line);
break;
}
onehistory.secs = (time_t)off_t_tmp;
skip_integer(s, ch);
}
info->history[nb_history++] = onehistory;
}
amfree(line);
while ((line = agets(infof)) != NULL) {
if (line[0] != '\0')
break;
amfree(line);
}
if (line == NULL) return -1;
amfree(line);
return rc;
}
int
main(
int argc,
char ** argv)
{
char *line = NULL;
char *qdisk = NULL;
char *qamdevice = NULL;
char *optstr = NULL;
char *err_extra = NULL;
char *s, *fp;
int ch;
dle_t *dle = NULL;
int level;
GSList *errlist;
level_t *alevel;
if (argc > 1 && argv && argv[1] && g_str_equal(argv[1], "--version")) {
printf("selfcheck-%s\n", VERSION);
return (0);
}
/* initialize */
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
openbsd_fd_inform();
safe_cd();
set_pname("selfcheck");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
add_amanda_log_handler(amanda_log_stderr);
add_amanda_log_handler(amanda_log_syslog);
dbopen(DBG_SUBDIR_CLIENT);
startclock();
dbprintf(_("version %s\n"), VERSION);
g_printf("OK version %s\n", VERSION);
print_platform();
if(argc > 2 && g_str_equal(argv[1], "amandad")) {
amandad_auth = g_strdup(argv[2]);
}
config_init(CONFIG_INIT_CLIENT, NULL);
/* (check for config errors comes later) */
check_running_as(RUNNING_AS_CLIENT_LOGIN);
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
/* handle all service requests */
/*@ignore@*/
for(; (line = agets(stdin)) != NULL; free(line)) {
/*@end@*/
if (line[0] == '\0')
continue;
if(strncmp_const(line, "OPTIONS ") == 0) {
if (g_options) {
g_printf(_("ERROR [Multiple OPTIONS line in selfcheck input]\n"));
error(_("Multiple OPTIONS line in selfcheck input\n"));
/*NOTREACHED*/
}
g_options = parse_g_options(line+8, 1);
if(!g_options->hostname) {
g_options->hostname = g_malloc(MAX_HOSTNAME_LENGTH+1);
gethostname(g_options->hostname, MAX_HOSTNAME_LENGTH);
g_options->hostname[MAX_HOSTNAME_LENGTH] = '\0';
}
g_printf("OPTIONS ");
if(am_has_feature(g_options->features, fe_rep_options_features)) {
g_printf("features=%s;", our_feature_string);
}
if(am_has_feature(g_options->features, fe_rep_options_hostname)) {
g_printf("hostname=%s;", g_options->hostname);
}
g_printf("\n");
fflush(stdout);
if (g_options->config) {
/* overlay this configuration on the existing (nameless) configuration */
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY,
g_options->config);
dbrename(get_config_name(), DBG_SUBDIR_CLIENT);
}
/* check for any config errors now */
if (config_errors(&errlist) >= CFGERR_ERRORS) {
char *errstr = config_errors_to_error_string(errlist);
g_printf("%s\n", errstr);
amfree(errstr);
amfree(line);
dbclose();
return 1;
}
if (am_has_feature(g_options->features, fe_req_xml)) {
break;
}
continue;
}
dle = alloc_dle();
s = line;
ch = *s++;
skip_whitespace(s, ch); /* find program name */
if (ch == '\0') {
goto err; /* no program */
}
dle->program = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0'; /* terminate the program name */
dle->program_is_application_api = 0;
if(g_str_equal(dle->program, "APPLICATION")) {
dle->program_is_application_api = 1;
skip_whitespace(s, ch); /* find dumper name */
if (ch == '\0') {
goto err; /* no program */
}
dle->program = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0'; /* terminate the program name */
}
if(strncmp_const(dle->program, "CALCSIZE") == 0) {
skip_whitespace(s, ch); /* find program name */
if (ch == '\0') {
goto err; /* no program */
}
dle->program = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
dle->estimatelist = g_slist_append(dle->estimatelist,
GINT_TO_POINTER(ES_CALCSIZE));
}
else {
dle->estimatelist = g_slist_append(dle->estimatelist,
GINT_TO_POINTER(ES_CLIENT));
}
skip_whitespace(s, ch); /* find disk name */
if (ch == '\0') {
goto err; /* no disk */
}
qdisk = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0'; /* terminate the disk name */
dle->disk = unquote_string(qdisk);
skip_whitespace(s, ch); /* find the device or level */
if (ch == '\0') {
goto err; /* no device or level */
}
if(!isdigit((int)s[-1])) {
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0'; /* terminate the device */
qamdevice = g_strdup(fp);
dle->device = unquote_string(qamdevice);
skip_whitespace(s, ch); /* find level number */
}
else {
dle->device = g_strdup(dle->disk);
qamdevice = g_strdup(qdisk);
}
amfree(qamdevice);
/* find level number */
if (ch == '\0' || sscanf(s - 1, "%d", &level) != 1) {
goto err; /* bad level */
}
alevel = g_new0(level_t, 1);
alevel->level = level;
dle->levellist = g_slist_append(dle->levellist, alevel);
skip_integer(s, ch);
skip_whitespace(s, ch);
if (ch && strncmp_const_skip(s - 1, "OPTIONS ", s, ch) == 0) {
skip_whitespace(s, ch); /* find the option string */
if(ch == '\0') {
goto err; /* bad options string */
}
optstr = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0'; /* terminate the options */
parse_options(optstr, dle, g_options->features, 1);
/*@ignore@*/
check_options(dle);
check_disk(dle);
/*@end@*/
} else if (ch == '\0') {
/* check all since no option */
need_samba=1;
need_rundump=1;
need_dump=1;
need_restore=1;
need_vdump=1;
need_vrestore=1;
need_xfsdump=1;
need_xfsrestore=1;
need_vxdump=1;
need_vxrestore=1;
need_runtar=1;
need_gnutar=1;
need_compress_path=1;
need_calcsize=1;
need_global_check=1;
/*@ignore@*/
check_disk(dle);
/*@end@*/
} else {
goto err; /* bad syntax */
}
free_dle(dle);
dle = NULL;
}
if (g_options == NULL) {
g_printf(_("ERROR [Missing OPTIONS line in selfcheck input]\n"));
error(_("Missing OPTIONS line in selfcheck input\n"));
/*NOTREACHED*/
}
if (am_has_feature(g_options->features, fe_req_xml)) {
char *errmsg = NULL;
dle_t *dles, *dle, *dle_next;
dles = amxml_parse_node_FILE(stdin, &errmsg);
if (errmsg) {
err_extra = errmsg;
goto err;
}
if (merge_dles_properties(dles, 1) == 0) {
goto checkoverall;
}
for (dle = dles; dle != NULL; dle = dle->next) {
run_client_scripts(EXECUTE_ON_PRE_HOST_AMCHECK, g_options, dle,
stdout);
}
for (dle = dles; dle != NULL; dle = dle->next) {
check_options(dle);
run_client_scripts(EXECUTE_ON_PRE_DLE_AMCHECK, g_options, dle,
stdout);
check_disk(dle);
run_client_scripts(EXECUTE_ON_POST_DLE_AMCHECK, g_options, dle,
stdout);
}
for (dle = dles; dle != NULL; dle = dle->next) {
run_client_scripts(EXECUTE_ON_POST_HOST_AMCHECK, g_options, dle,
stdout);
}
for (dle = dles; dle != NULL; dle = dle_next) {
dle_next = dle->next;
free_dle(dle);
}
}
checkoverall:
check_overall();
amfree(line);
amfree(our_feature_string);
am_release_feature_set(our_features);
our_features = NULL;
free_g_options(g_options);
dbclose();
return 0;
err:
if (err_extra) {
g_printf(_("ERROR [FORMAT ERROR IN REQUEST PACKET %s]\n"), err_extra);
dbprintf(_("REQ packet is bogus: %s\n"), err_extra);
} else {
g_printf(_("ERROR [FORMAT ERROR IN REQUEST PACKET]\n"));
dbprintf(_("REQ packet is bogus\n"));
}
amfree(err_extra);
amfree(line);
if (dle)
free_dle(dle);
dbclose();
return 1;
}
/*
* check ~/.k5amandahosts to see if this principal is allowed in. If it's
* hardcoded, then we don't check the realm
*/
static char *
krb5_checkuser( char * host,
char * name,
char * realm)
{
#ifdef AMANDA_PRINCIPAL
if(strcmp(name, AMANDA_PRINCIPAL) == 0) {
return(NULL);
} else {
return(vstrallocf(_("does not match compiled in default")));
}
#else
struct passwd *pwd;
char *ptmp;
char *result = _("generic error"); /* default is to not permit */
FILE *fp = NULL;
struct stat sbuf;
uid_t localuid;
char *line = NULL;
char *filehost = NULL, *fileuser = NULL, *filerealm = NULL;
assert( host != NULL);
assert( name != NULL);
if((pwd = getpwnam(CLIENT_LOGIN)) == NULL) {
result = vstrallocf(_("can not find user %s"), CLIENT_LOGIN);
}
localuid = pwd->pw_uid;
#ifdef USE_AMANDAHOSTS
ptmp = stralloc2(pwd->pw_dir, "/.k5amandahosts");
#else
ptmp = stralloc2(pwd->pw_dir, "/.k5login");
#endif
if(!ptmp) {
result = vstrallocf(_("could not find home directory for %s"), CLIENT_LOGIN);
goto common_exit;
}
/*
* check to see if the ptmp file does nto exist.
*/
if(access(ptmp, R_OK) == -1 && errno == ENOENT) {
/*
* in this case we check to see if the principal matches
* the destination user mimicing the .k5login functionality.
*/
if(strcmp(name, CLIENT_LOGIN) != 0) {
result = vstrallocf(_("%s does not match %s"),
name, CLIENT_LOGIN);
return result;
}
result = NULL;
goto common_exit;
}
auth_debug(1, _("opening ptmp: %s\n"), (ptmp)?ptmp: "NULL!");
if((fp = fopen(ptmp, "r")) == NULL) {
result = vstrallocf(_("can not open %s"), ptmp);
return result;
}
auth_debug(1, _("opened ptmp\n"));
if (fstat(fileno(fp), &sbuf) != 0) {
result = vstrallocf(_("cannot fstat %s: %s"), ptmp, strerror(errno));
goto common_exit;
}
if (sbuf.st_uid != localuid) {
result = vstrallocf(_("%s is owned by %ld, should be %ld"),
ptmp, (long)sbuf.st_uid, (long)localuid);
goto common_exit;
}
if ((sbuf.st_mode & 077) != 0) {
result = vstrallocf(
_("%s: incorrect permissions; file must be accessible only by its owner"), ptmp);
goto common_exit;
}
while ((line = agets(fp)) != NULL) {
if (line[0] == '\0') {
amfree(line);
continue;
}
/* if there's more than one column, then it's the host */
if( (filehost = strtok(line, " \t")) == NULL) {
amfree(line);
continue;
}
/*
* if there's only one entry, then it's a username and we have
* no hostname. (so the principal is allowed from anywhere.
*/
if((fileuser = strtok(NULL, " \t")) == NULL) {
fileuser = filehost;
filehost = NULL;
}
if(filehost && strcmp(filehost, host) != 0) {
amfree(line);
continue;
} else {
auth_debug(1, _("found a host match\n"));
}
if( (filerealm = strchr(fileuser, '@')) != NULL) {
*filerealm++ = '\0';
}
/*
* we have a match. We're going to be a little bit insecure
* and indicate that the principal is correct but the realm is
* not if that's the case. Technically we should say nothing
* and let the user figure it out, but it's helpful for debugging.
* You likely only get this far if you've turned on cross-realm auth
* anyway...
*/
auth_debug(1, _("comparing %s %s\n"), fileuser, name);
if(strcmp(fileuser, name) == 0) {
auth_debug(1, _("found a match!\n"));
if(realm && filerealm && (strcmp(realm, filerealm)!=0)) {
amfree(line);
continue;
}
result = NULL;
amfree(line);
goto common_exit;
}
amfree(line);
}
result = vstrallocf(_("no match in %s"), ptmp);
common_exit:
afclose(fp);
return(result);
#endif /* AMANDA_PRINCIPAL */
}
static void
check_disk(
dle_t *dle)
{
char *device = NULL;
char *err = NULL;
char *user_and_password = NULL;
char *domain = NULL;
char *share = NULL, *subdir = NULL;
size_t lpass = 0;
int amode = R_OK;
int access_result;
char *access_type;
char *extra_info = NULL;
char *qdisk = NULL;
char *qamdevice = NULL;
char *qdevice = NULL;
if (dle->disk) {
need_global_check=1;
qdisk = quote_string(dle->disk);
qamdevice = quote_string(dle->device);
device = g_strdup("nodevice");
dbprintf(_("checking disk %s\n"), qdisk);
if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE) {
if (dle->device[0] == '/' && dle->device[1] == '/') {
err = g_strdup_printf(
_("Can't use CALCSIZE for samba estimate, use CLIENT: %s"),
dle->device);
goto common_exit;
}
}
if (g_str_equal(dle->program, "GNUTAR")) {
if(dle->device[0] == '/' && dle->device[1] == '/') {
#ifdef SAMBA_CLIENT
int nullfd, checkerr;
int passwdfd;
char *pwtext;
size_t pwtext_len;
pid_t checkpid;
amwait_t retstat;
pid_t wpid;
int rc;
char *line;
char *sep;
FILE *ferr;
char *pw_fd_env;
int errdos;
parsesharename(dle->device, &share, &subdir);
if (!share) {
err = g_strdup_printf(
_("cannot parse for share/subdir disk entry %s"),
dle->device);
goto common_exit;
}
if ((subdir) && (SAMBA_VERSION < 2)) {
err = g_strdup_printf(_("subdirectory specified for share '%s' but, samba is not v2 or better"),
dle->device);
goto common_exit;
}
if ((user_and_password = findpass(share, &domain)) == NULL) {
err = g_strdup_printf(_("cannot find password for %s"),
dle->device);
goto common_exit;
}
lpass = strlen(user_and_password);
if ((pwtext = strchr(user_and_password, '%')) == NULL) {
err = g_strdup_printf(
_("password field not \'user%%pass\' for %s"),
dle->device);
goto common_exit;
}
*pwtext++ = '\0';
pwtext_len = (size_t)strlen(pwtext);
amfree(device);
if ((device = makesharename(share, 0)) == NULL) {
err = g_strdup_printf(_("cannot make share name of %s"), share);
goto common_exit;
}
if ((nullfd = open("/dev/null", O_RDWR)) == -1) {
err = g_strdup_printf(_("Cannot access /dev/null : %s"),
strerror(errno));
goto common_exit;
}
if (pwtext_len > 0) {
pw_fd_env = "PASSWD_FD";
} else {
pw_fd_env = "dummy_PASSWD_FD";
}
checkpid = pipespawn(SAMBA_CLIENT, STDERR_PIPE|PASSWD_PIPE, 0,
&nullfd, &nullfd, &checkerr,
pw_fd_env, &passwdfd,
"smbclient",
device,
*user_and_password ? "-U" : skip_argument,
*user_and_password ? user_and_password
: skip_argument,
"-E",
domain ? "-W" : skip_argument,
domain ? domain : skip_argument,
#if SAMBA_VERSION >= 2
subdir ? "-D" : skip_argument,
subdir ? subdir : skip_argument,
#endif
"-c", "quit",
NULL);
checkpid = checkpid;
amfree(domain);
aclose(nullfd);
/*@ignore@*/
if ((pwtext_len > 0) &&
full_write(passwdfd, pwtext, pwtext_len) < pwtext_len) {
err = g_strdup_printf(_("password write failed: %s: %s"),
dle->device, strerror(errno));
aclose(passwdfd);
goto common_exit;
}
/*@end@*/
memset(user_and_password, '\0', (size_t)lpass);
amfree(user_and_password);
aclose(passwdfd);
ferr = fdopen(checkerr, "r");
if (!ferr) {
g_printf(_("ERROR [Can't fdopen ferr: %s]\n"), strerror(errno));
error(_("Can't fdopen ferr: %s"), strerror(errno));
/*NOTREACHED*/
}
sep = "";
errdos = 0;
for(sep = ""; (line = agets(ferr)) != NULL; free(line)) {
if (line[0] == '\0')
continue;
strappend(extra_info, sep);
strappend(extra_info, line);
sep = ": ";
if(strstr(line, "ERRDOS") != NULL) {
errdos = 1;
}
}
afclose(ferr);
checkerr = -1;
rc = 0;
sep = "";
while ((wpid = wait(&retstat)) != -1) {
if (!WIFEXITED(retstat) || WEXITSTATUS(retstat) != 0) {
char *exitstr = str_exit_status("smbclient", retstat);
strappend(err, sep);
strappend(err, exitstr);
sep = "\n";
amfree(exitstr);
rc = 1;
}
}
if (errdos != 0 || rc != 0) {
char *tmpbuf;
if (extra_info) {
tmpbuf = g_strdup_printf( _("samba access error: %s: %s %s"),
dle->device, extra_info, err);
amfree(extra_info);
} else {
tmpbuf = g_strdup_printf(_("samba access error: %s: %s"),
dle->device, err);
}
g_free(err);
err = tmpbuf;
}
#else
err = g_strdup_printf(
_("This client is not configured for samba: %s"),
qdisk);
#endif
goto common_exit;
}
amode = F_OK;
amfree(device);
device = amname_to_dirname(dle->device);
} else if (g_str_equal(dle->program, "DUMP")) {
if(dle->device[0] == '/' && dle->device[1] == '/') {
err = g_strdup_printf(
_("The DUMP program cannot handle samba shares, use GNUTAR: %s"),
qdisk);
goto common_exit;
}
#ifdef VDUMP /* { */
#ifdef DUMP /* { */
if (g_str_equal(amname_to_fstype(dle->device), "advfs"))
#else /* }{*/
if (1)
#endif /* } */
{
amfree(device);
device = amname_to_dirname(dle->device);
amode = F_OK;
} else
#endif /* } */
{
amfree(device);
device = amname_to_devname(dle->device);
#ifdef USE_RUNDUMP
amode = F_OK;
#else
amode = R_OK;
#endif
}
}
}
if (dle->program_is_application_api) {
pid_t application_api_pid;
backup_support_option_t *bsu;
int app_err[2];
GPtrArray *errarray;
bsu = backup_support_option(dle->program, g_options, dle->disk,
dle->device, &errarray);
if (!bsu) {
char *line;
guint i;
for (i=0; i < errarray->len; i++) {
line = g_ptr_array_index(errarray, i);
fprintf(stdout, _("ERROR Application '%s': %s\n"),
dle->program, line);
amfree(line);
}
err = g_strdup_printf(_("Application '%s': can't run support command"),
dle->program);
goto common_exit;
}
if (dle->data_path == DATA_PATH_AMANDA &&
(bsu->data_path_set & DATA_PATH_AMANDA)==0) {
g_printf("ERROR application %s doesn't support amanda data-path\n",
dle->program);
}
if (dle->data_path == DATA_PATH_DIRECTTCP &&
(bsu->data_path_set & DATA_PATH_DIRECTTCP)==0) {
g_printf("ERROR application %s doesn't support directtcp data-path\n",
dle->program);
}
if (GPOINTER_TO_INT(dle->estimatelist->data) == ES_CALCSIZE &&
!bsu->calcsize) {
g_printf("ERROR application %s doesn't support calcsize estimate\n",
dle->program);
}
if (dle->include_file && dle->include_file->nb_element > 0 &&
!bsu->include_file) {
g_printf("ERROR application %s doesn't support include-file\n",
dle->program);
}
if (dle->include_list && dle->include_list->nb_element > 0 &&
!bsu->include_list) {
g_printf("ERROR application %s doesn't support include-list\n",
dle->program);
}
if (dle->include_optional && !bsu->include_optional) {
g_printf("ERROR application %s doesn't support optional include\n",
dle->program);
}
if (dle->exclude_file && dle->exclude_file->nb_element > 0 &&
!bsu->exclude_file) {
g_printf("ERROR application %s doesn't support exclude-file\n",
dle->program);
}
if (dle->exclude_list && dle->exclude_list->nb_element > 0 &&
!bsu->exclude_list) {
g_printf("ERROR application %s doesn't support exclude-list\n",
dle->program);
}
if (dle->exclude_optional && !bsu->exclude_optional) {
g_printf("ERROR application %s doesn't support optional exclude\n",
dle->program);
}
fflush(stdout);fflush(stderr);
if (pipe(app_err) < 0) {
err = g_strdup_printf(_("Application '%s': can't create pipe"),
dle->program);
goto common_exit;
}
switch (application_api_pid = fork()) {
case -1:
err = g_strdup_printf(_("fork failed: %s"), strerror(errno));
goto common_exit;
case 0: /* child */
{
GPtrArray *argv_ptr = g_ptr_array_new();
GPtrArray *argv_quoted = g_ptr_array_new();
gchar **args, **quoted_strings, **ptr;
char *cmd = g_strjoin(NULL, APPLICATION_DIR, "/", dle->program, NULL);
GSList *scriptlist;
script_t *script;
estimatelist_t el;
char *cmdline;
aclose(app_err[0]);
dup2(app_err[1], 2);
g_ptr_array_add(argv_ptr, g_strdup(dle->program));
g_ptr_array_add(argv_ptr, g_strdup("selfcheck"));
if (bsu->message_line == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--message"));
g_ptr_array_add(argv_ptr, g_strdup("line"));
}
if (g_options->config != NULL && bsu->config == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--config"));
g_ptr_array_add(argv_ptr, g_strdup(g_options->config));
}
if (g_options->hostname != NULL && bsu->host == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--host"));
g_ptr_array_add(argv_ptr, g_strdup(g_options->hostname));
}
if (dle->disk != NULL && bsu->disk == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--disk"));
g_ptr_array_add(argv_ptr, g_strdup(dle->disk));
}
if (dle->device) {
g_ptr_array_add(argv_ptr, g_strdup("--device"));
g_ptr_array_add(argv_ptr, g_strdup(dle->device));
}
if (dle->create_index && bsu->index_line == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--index"));
g_ptr_array_add(argv_ptr, g_strdup("line"));
}
if (dle->record && bsu->record == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--record"));
}
for (el = dle->estimatelist; el != NULL; el=el->next) {
estimate_t estimate = (estimate_t)GPOINTER_TO_INT(el->data);
if (estimate == ES_CALCSIZE && bsu->calcsize == 1) {
g_ptr_array_add(argv_ptr, g_strdup("--calcsize"));
}
}
application_property_add_to_argv(argv_ptr, dle, bsu,
g_options->features);
for (scriptlist = dle->scriptlist; scriptlist != NULL;
scriptlist = scriptlist->next) {
script = (script_t *)scriptlist->data;
if (script->result && script->result->proplist) {
property_add_to_argv(argv_ptr,
script->result->proplist);
}
}
g_ptr_array_add(argv_ptr, NULL);
args = (gchar **)g_ptr_array_free(argv_ptr, FALSE);
/*
* Build the command line to display
*/
g_ptr_array_add(argv_quoted, g_strdup(cmd));
for (ptr = args; *ptr; ptr++)
g_ptr_array_add(argv_quoted, quote_string(*ptr));
g_ptr_array_add(argv_quoted, NULL);
quoted_strings = (gchar **)g_ptr_array_free(argv_quoted, FALSE);
cmdline = g_strjoinv(" ", quoted_strings);
g_strfreev(quoted_strings);
dbprintf(_("Spawning \"%s\" in pipeline\n"), cmdline);
amfree(cmdline);
safe_fd(-1, 0);
execve(cmd, args, safe_env());
g_printf(_("ERROR [Can't execute %s: %s]\n"), cmd, strerror(errno));
exit(127);
}
default: /* parent */
{
int status;
FILE *app_stderr;
char *line;
aclose(app_err[1]);
app_stderr = fdopen(app_err[0], "r");
if (!app_stderr) {
g_printf(_("ERROR [Can't fdopen app_stderr: %s]\n"),
strerror(errno));
error(_("Can't fdopen app_stderr: %s"), strerror(errno));
/*NOTREACHED*/
}
while((line = agets(app_stderr)) != NULL) {
if (strlen(line) > 0) {
fprintf(stdout, "ERROR Application '%s': %s\n",
dle->program, line);
dbprintf("ERROR %s\n", line);
}
amfree(line);
}
fclose(app_stderr);
if (waitpid(application_api_pid, &status, 0) < 0) {
err = g_strdup_printf(_("waitpid failed: %s"),
strerror(errno));
goto common_exit;
} else if (!WIFEXITED(status)) {
err = g_strdup_printf(_("Application '%s': exited with signal %d"),
dle->program, WTERMSIG(status));
goto common_exit;
} else if (WEXITSTATUS(status) != 0) {
err = g_strdup_printf(_("Application '%s': exited with status %d"),
dle->program, WEXITSTATUS(status));
goto common_exit;
}
}
}
amfree(bsu);
fflush(stdout);fflush(stderr);
amfree(device);
amfree(qamdevice);
amfree(qdisk);
return;
}
if (device) {
qdevice = quote_string(device);
dbprintf(_("device %s\n"), qdevice);
/* skip accessability test if this is an AFS entry */
if(strncmp_const(device, "afs:") != 0) {
#ifdef CHECK_FOR_ACCESS_WITH_OPEN
access_result = open(device, O_RDONLY);
access_type = "open";
#else
access_result = access(device, amode);
access_type = "access";
#endif
if(access_result == -1) {
err = g_strdup_printf(_("Could not %s %s (%s): %s"),
access_type, qdevice, qdisk, strerror(errno));
}
#ifdef CHECK_FOR_ACCESS_WITH_OPEN
aclose(access_result);
#endif
}
}
common_exit:
if (!qdevice)
qdevice = quote_string(device);
amfree(share);
amfree(subdir);
if(user_and_password) {
memset(user_and_password, '\0', (size_t)lpass);
amfree(user_and_password);
}
amfree(domain);
if(err) {
g_printf(_("ERROR %s\n"), err);
dbprintf(_("%s\n"), err);
amfree(err);
} else {
if (dle->disk) {
g_printf("OK %s\n", qdisk);
dbprintf(_("disk %s OK\n"), qdisk);
}
if (dle->device) {
g_printf("OK %s\n", qamdevice);
dbprintf(_("amdevice %s OK\n"), qamdevice);
}
if (device) {
g_printf("OK %s\n", qdevice);
dbprintf(_("device %s OK\n"), qdevice);
}
}
if(extra_info) {
dbprintf(_("extra info: %s\n"), extra_info);
amfree(extra_info);
}
amfree(qdisk);
amfree(qdevice);
amfree(qamdevice);
amfree(device);
/* XXX perhaps do something with level: read dumpdates and sanity check */
}