int gauge(char * text, int height, int width, poptContext optCon, int fd,
int flags) {
newtComponent form, scale, tb;
int top;
char * arg, * end;
int val;
FILE * f = fdopen(fd, "r");
char buf[3000];
char buf3[50];
int i;
setlinebuf(f);
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
val = strtoul(arg, &end, 10);
if (*end) return DLG_ERROR;
tb = textbox(height - 3, width - 2, text, flags, &top);
form = newtForm(NULL, NULL, 0);
scale = newtScale(2, height - 2, width - 4, 100);
newtScaleSet(scale, val);
newtFormAddComponents(form, tb, scale, NULL);
newtDrawForm(form);
newtRefresh();
while (fgets(buf, sizeof(buf) - 1, f)) {
buf[strlen(buf) - 1] = '\0';
if (!strcmp(buf, "XXX")) {
fgets(buf3, sizeof(buf3) - 1, f);
buf3[strlen(buf3) - 1] = '\0';
arg = buf3;
i = 0;
while (fgets(buf + i, sizeof(buf) - 1 - i, f)) {
buf[strlen(buf) - 1] = '\0';
if (!strcmp(buf + i, "XXX")) {
*(buf + i) = '\0';
break;
}
i = strlen(buf);
}
newtTextboxSetText(tb, buf);
} else {
arg = buf;
}
val = strtoul(buf, &end, 10);
if (!*end) {
newtScaleSet(scale, val);
newtDrawForm(form);
newtRefresh();
}
}
return DLG_OKAY;
}
static VALUE rb_ext_Screen_Refresh()
{
newtRefresh();
return Qnil;
}
/**
* @brief Remove the top window
*/
void newtPopWindow(void) {
newtPopWindowNoRefresh();
newtRefresh();
}
/* This is a groovie dialog for showing network info. Takes a keyvalue list,
* a colour and a dhcp flag. Shows the current settings, and rewrites them
* if necessary. DHCP flag sets wether to show the dhcp checkbox. */
int changeaddress(struct keyvalue *kv, char *colour, int typeflag,
char *defaultdhcphostname)
{
char *addressresult;
char *netmaskresult;
char *dhcphostnameresult;
char *dhcpforcemturesult;
struct newtExitStruct es;
newtComponent header;
newtComponent addresslabel;
newtComponent netmasklabel;
newtComponent dhcphostnamelabel;
newtComponent dhcpforcemtulabel;
newtComponent ok, cancel;
char message[1000];
char temp[STRING_SIZE];
char addressfield[STRING_SIZE];
char netmaskfield[STRING_SIZE];
char typefield[STRING_SIZE];
char dhcphostnamefield[STRING_SIZE];
char dhcpforcemtufield[STRING_SIZE];
int error;
int result = 0;
char type[STRING_SIZE];
int startstatictype = 0;
int startdhcptype = 0;
int startpppoetype = 0;
/* Build some key strings. */
sprintf(addressfield, "%s_ADDRESS", colour);
sprintf(netmaskfield, "%s_NETMASK", colour);
sprintf(typefield, "%s_TYPE", colour);
sprintf(dhcphostnamefield, "%s_DHCP_HOSTNAME", colour);
sprintf(dhcpforcemtufield, "%s_DHCP_FORCE_MTU", colour);
sprintf(message, _("Interface - %s"), colour);
newtCenteredWindow(44, (typeflag ? 18 : 12), message);
networkform = newtForm(NULL, NULL, 0);
sprintf(message, _("Enter the IP address information for the %s interface."), colour);
header = newtTextboxReflowed(1, 1, message, 42, 0, 0, 0);
newtFormAddComponent(networkform, header);
/* See if we need a dhcp checkbox. If we do, then we shift the contents
* of the window down two rows to make room. */
if (typeflag)
{
strcpy(temp, "STATIC"); findkey(kv, typefield, temp);
if (strcmp(temp, "STATIC") == 0) startstatictype = 1;
if (strcmp(temp, "DHCP") == 0) startdhcptype = 1;
if (strcmp(temp, "PPPOE") == 0) startpppoetype = 1;
statictyperadio = newtRadiobutton(2, 4, _("Static"), startstatictype, NULL);
dhcptyperadio = newtRadiobutton(2, 5, _("DHCP"), startdhcptype, statictyperadio);
pppoetyperadio = newtRadiobutton(2, 6, _("PPP DIALUP (PPPoE, modem, ATM ...)"),
startpppoetype, dhcptyperadio);
newtFormAddComponents(networkform, statictyperadio, dhcptyperadio,
pppoetyperadio, NULL);
newtComponentAddCallback(statictyperadio, networkdialogcallbacktype, NULL);
newtComponentAddCallback(dhcptyperadio, networkdialogcallbacktype, NULL);
newtComponentAddCallback(pppoetyperadio, networkdialogcallbacktype, NULL);
dhcphostnamelabel = newtTextbox(2, 8, 18, 1, 0);
newtTextboxSetText(dhcphostnamelabel, _("DHCP Hostname:"));
dhcpforcemtulabel = newtTextbox(2, 9, 18, 1, 0);
newtTextboxSetText(dhcpforcemtulabel, _("Force DHCP MTU:"));
strcpy(temp, defaultdhcphostname);
findkey(kv, dhcphostnamefield, temp);
dhcphostnameentry = newtEntry(20, 8, temp, 20, &dhcphostnameresult, 0);
strcpy(temp, "");
findkey(kv, dhcpforcemtufield, temp);
dhcpforcemtuentry = newtEntry(20, 9, temp, 20, &dhcpforcemturesult, 0);
newtFormAddComponent(networkform, dhcphostnamelabel);
newtFormAddComponent(networkform, dhcphostnameentry);
newtFormAddComponent(networkform, dhcpforcemtulabel);
newtFormAddComponent(networkform, dhcpforcemtuentry);
if (startdhcptype == 0)
{
newtEntrySetFlags(dhcphostnameentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtEntrySetFlags(dhcpforcemtuentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
}
}
/* Address */
addresslabel = newtTextbox(2, (typeflag ? 11 : 4) + 0, 18, 1, 0);
newtTextboxSetText(addresslabel, _("IP address:"));
strcpy(temp, "");
findkey(kv, addressfield, temp);
addressentry = newtEntry(20, (typeflag ? 11 : 4) + 0, temp, 20, &addressresult, 0);
newtEntrySetFilter(addressentry, ip_input_filter, NULL);
if (typeflag == 1 && startstatictype == 0)
newtEntrySetFlags(addressentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtFormAddComponent(networkform, addresslabel);
newtFormAddComponent(networkform, addressentry);
/* Netmask */
netmasklabel = newtTextbox(2, (typeflag ? 11 : 4) + 1, 18, 1, 0);
newtTextboxSetText(netmasklabel, _("Network mask:"));
strcpy(temp, "255.255.255.0"); findkey(kv, netmaskfield, temp);
netmaskentry = newtEntry(20, (typeflag ? 11 : 4) + 1, temp, 20, &netmaskresult, 0);
newtEntrySetFilter(netmaskentry, ip_input_filter, NULL);
if (typeflag == 1 && startstatictype == 0)
newtEntrySetFlags(netmaskentry, NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
newtFormAddComponent(networkform, netmasklabel);
newtFormAddComponent(networkform, netmaskentry);
/* Buttons. */
ok = newtButton(8, (typeflag ? 14 : 7), _("OK"));
cancel = newtButton(26, (typeflag ? 14 : 7), _("Cancel"));
newtFormAddComponents(networkform, ok, cancel, NULL);
newtRefresh();
newtDrawForm(networkform);
do
{
error = 0;
newtFormRun(networkform, &es);
if (es.u.co == ok)
{
/* OK was pressed; verify the contents of each entry. */
strcpy(message, _("The following fields are invalid:"));
strcat(message, "\n\n");
strcpy(type, "STATIC");
if (typeflag)
gettype(type);
if (strcmp(type, "STATIC") == 0)
{
if (inet_addr(addressresult) == INADDR_NONE)
{
strcat(message, _("IP address"));
strcat(message, "\n");
error = 1;
}
if (inet_addr(netmaskresult) == INADDR_NONE)
{
strcat(message, _("Network mask"));
strcat(message, "\n");
error = 1;
}
}
if (strcmp(type, "DHCP") == 0)
{
if (!strlen(dhcphostnameresult))
{
strcat(message, _("DHCP hostname"));
strcat(message, "\n");
error = 1;
}
}
if (error)
errorbox(message);
else
{
/* No errors! Set new values, depending on dhcp flag etc. */
if (typeflag)
{
replacekeyvalue(kv, dhcphostnamefield, dhcphostnameresult);
replacekeyvalue(kv, dhcpforcemtufield, dhcpforcemturesult);
if (strcmp(type, "STATIC") != 0)
{
replacekeyvalue(kv, addressfield, "0.0.0.0");
replacekeyvalue(kv, netmaskfield, "0.0.0.0");
}
else
{
replacekeyvalue(kv, addressfield, addressresult);
replacekeyvalue(kv, netmaskfield, netmaskresult);
}
replacekeyvalue(kv, typefield, type);
}
else
{
replacekeyvalue(kv, addressfield, addressresult);
replacekeyvalue(kv, netmaskfield, netmaskresult);
}
setnetaddress(kv, colour);
result = 1;
}
}
/* Workaround for a bug that dhcp radiobutton also end the dialog at arm
*/
else {
if (es.u.co != cancel) {
error = 1;
}
}
}
while (error);
newtFormDestroy(networkform);
newtPopWindow();
return result;
}
// return a malloc()ed path
char *filesel(char *dr)
{
newtComponent lb, b1, b2, b3, l1, l2, f;
const char *enr2, *enr3;
char *curv;
char curvv[PATH_MAX]; // stupid, but who cares...
int i, cnt;
fde *sel, *sela;
char cwd[PATH_MAX], cwdcd[PATH_MAX], *ret=NULL;
struct newtExitStruct es;
struct stat st;
newtCenteredWindow(65, 15, i18n("Select path"));
f = newtForm(NULL, NULL, 0);
b1 = newtCompactButton(59, 14, i18n("Ok"));
b3 = newtCompactButton(45, 14, i18n("Cancel"));
l2 = newtEntry(1, 14, "", 25, &enr3, NEWT_FLAG_SCROLL);
b2 = newtCompactButton(26, 14, i18n("Create dir"));
lb = newtListbox(1, 2, 12, /*NEWT_FLAG_MULTIPLE |*/ /*NEWT_FLAG_BORDER | */
NEWT_FLAG_RETURNEXIT |
NEWT_FLAG_SCROLL | NEWT_FLAG_SHOWCURSOR);
if(dr && strlen(dr) > 0)
{
// let it show the file or dir at any case
l1 = newtEntry(1, 0, dr, 60, &enr2, NEWT_FLAG_SCROLL | NEWT_FLAG_DISABLED);
stat(dr,&st);
if(S_ISDIR(st.st_mode))
{
dir_here(lb,dr);
strcpy(cwd,dr);
} else
{
dir_here(lb,dirname(dr));
strcpy(cwd,dirname(dr));
}
}
else
{
// if NULL, show the current dir
l1 = newtEntry(1, 0, get_current_dir_name(), 60, &enr2, NEWT_FLAG_SCROLL | NEWT_FLAG_DISABLED);
dir_here(lb,get_current_dir_name());
strcpy(cwd,get_current_dir_name());
}
newtListboxSetWidth(lb,63);
newtFormAddComponents(f, lb,l1, l2, b2, b1, b3, NULL);
newtRefresh();
newtFormSetTimer(f, 200);
do
{
newtFormRun(f, &es);
if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == lb)
{
sel=(fde*)newtListboxGetCurrent(lb);
if (sel && S_ISDIR(sel->st.st_mode))
{
cnt=newtListboxItemCount(lb);
// delete items there:
for(i=0; i < cnt; i++)
{
newtListboxGetEntry(lb, i, &curv, (void**)&sela);
if(sela != sel)
{
free(sela->name);
free(sela);
}
else
{
strcpy(curvv, curv);
}
}
newtListboxClear(lb);
dir_here(lb,sel->name);
if(strcmp(curvv,"..") == 0) set_lb_cursor(lb,cwdcd);
strcpy(cwd,sel->name);
strcpy(cwdcd,sel->name);
newtEntrySet(l1, sel->name, 1);
if(sel)
{
free(sel->name);
free(sel);
}
}
if(sel && S_ISREG(sel->st.st_mode)) // is a directory
{
newtEntrySet(l1, sel->name, 1);
}
}
else if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == b2)
{
if(strlen(enr3) > 0)
{
strcpy(cwdcd,cwd);
strcat(cwdcd,"/");
strcat(cwdcd,enr3);
if(mkdir(cwdcd,0755) == 0)
{
newtListboxClear(lb);
dir_here(lb,cwd);
set_lb_cursor(lb,cwdcd);
newtEntrySet(l2, "", 1);
}
}
}
else if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == b1)
{
ret=strdup(enr2);
}
}
while (es.reason != es.NEWT_EXIT_COMPONENT || es.u.co == lb || es.u.co == b2);
newtFormDestroy(f);
newtPopWindow();
return ret;
}
/**
* @brief Wait for a keystroke
*/
void newtWaitForKey(void) {
newtRefresh();
getkey();
newtClearKeyBuffer();
}
// =======================================================
int CRestoringWindow::runForm()
{
BEGIN;
newtRefresh();
RETURN_int(0);
}
int main(void) {
newtComponent b1, b2, r1, r2, r3, e2, e3, l1, l2, l3, scale;
newtComponent lb, t, rsf, answer, timeLabel;
newtComponent cs[10];
newtComponent f, chklist, e1;
struct callbackInfo cbis[3];
char results[10];
char * enr2, * enr3, * scaleVal;
void ** selectedList;
int i, numsel;
char buf[20];
const char * spinner = "-\\|/\\|/";
const char * spinState;
struct newtExitStruct es;
newtInit();
newtCls();
newtSetSuspendCallback(suspend, NULL);
newtSetHelpCallback(helpCallback);
newtDrawRootText(0, 0, "Newt test program");
newtPushHelpLine(NULL);
newtDrawRootText(-50, 0, "More root text");
newtOpenWindow(2, 2, 30, 10, "first window");
newtOpenWindow(10, 5, 65, 16, "window 2");
f = newtForm(NULL, "This is some help text", 0);
chklist = newtForm(NULL, NULL, 0);
b1 = newtButton(3, 1, "Exit");
b2 = newtButton(18, 1, "Update");
r1 = newtRadiobutton(20, 10, "Choice 1", 0, NULL);
r2 = newtRadiobutton(20, 11, "Chc 2", 1, r1);
r3 = newtRadiobutton(20, 12, "Choice 3", 0, r2);
rsf = newtForm(NULL, NULL, 0);
newtFormAddComponents(rsf, r1, r2, r3, NULL);
newtFormSetBackground(rsf, NEWT_COLORSET_CHECKBOX);
for (i = 0; i < 10; i++) {
sprintf(buf, "Check %d", i);
cs[i] = newtCheckbox(3, 10 + i, buf, ' ', NULL, &results[i]);
newtFormAddComponent(chklist, cs[i]);
}
l1 = newtLabel(3, 6, "Scale:");
l2 = newtLabel(3, 7, "Scrolls:");
l3 = newtLabel(3, 8, "Hidden:");
e1 = newtEntry(12, 6, "", 20, &scaleVal, 0);
e2 = newtEntry(12, 7, "Default", 20, &enr2, NEWT_FLAG_SCROLL);
/* e3 = newtEntry(12, 8, NULL, 20, &enr3, NEWT_FLAG_HIDDEN); */
e3 = newtEntry(12, 8, NULL, 20, &enr3, NEWT_FLAG_PASSWORD);
cbis[0].state = &results[0];
cbis[0].en = e1;
newtComponentAddCallback(cs[0], disableCallback, &cbis[0]);
scale = newtScale(3, 14, 32, 100);
newtFormSetHeight(chklist, 3);
newtFormAddComponents(f, b1, b2, l1, l2, l3, e1, e2, e3, chklist, NULL);
newtFormAddComponents(f, rsf, scale, NULL);
lb = newtListbox(45, 1, 6, NEWT_FLAG_MULTIPLE | NEWT_FLAG_BORDER |
NEWT_FLAG_SCROLL | NEWT_FLAG_SHOWCURSOR);
newtListboxAppendEntry(lb, "First", (void *) 1);
newtListboxAppendEntry(lb, "Second", (void *) 2);
newtListboxAppendEntry(lb, "Third", (void *) 3);
newtListboxAppendEntry(lb, "Fourth", (void *) 4);
newtListboxAppendEntry(lb, "Sixth", (void *) 6);
newtListboxAppendEntry(lb, "Seventh", (void *) 7);
newtListboxAppendEntry(lb, "Eighth", (void *) 8);
newtListboxAppendEntry(lb, "Ninth", (void *) 9);
newtListboxAppendEntry(lb, "Tenth", (void *) 10);
newtListboxInsertEntry(lb, "Fifth", (void *) 5, (void *) 4);
newtListboxInsertEntry(lb, "Eleventh", (void *) 11, (void *) 10);
newtListboxDeleteEntry(lb, (void *) 11);
spinState = spinner;
timeLabel = newtLabel(45, 8, "Spinner: -");
t = newtTextbox(45, 10, 17, 5, NEWT_FLAG_WRAP);
newtTextboxSetText(t, "This is some text does it look okay?\nThis should be alone.\nThis shouldn't be printed");
newtFormAddComponents(f, lb, timeLabel, t, NULL);
newtRefresh();
newtFormSetTimer(f, 200);
do {
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == b2) {
newtScaleSet(scale, atoi(scaleVal));
newtRefresh();
answer = NULL;
} else if (es.reason == NEWT_EXIT_TIMER) {
spinState++;
if (!*spinState) spinState = spinner;
sprintf(buf, "Spinner: %c", *spinState);
newtLabelSetText(timeLabel, buf);
}
} while (es.reason != NEWT_EXIT_COMPONENT || es.u.co == b2);
scaleVal = strdup(scaleVal);
enr2 = strdup(enr2);
enr3 = strdup(enr3);
selectedList = newtListboxGetSelection(lb, &numsel);
newtFormDestroy(f);
newtPopWindow();
newtPopWindow();
newtFinished();
printf("got string 1: %s\n", scaleVal);
printf("got string 2: %s\n", enr2);
printf("got string 3: %s\n", enr3);
if(selectedList) {
printf("\nSelected listbox items:\n");
for(i = 0; i < numsel; i++)
puts(selectedList[i]);
}
return 0;
}
// =======================================================
void CRestoringWindow::showStats(const time_t timeStart, QWORD qwBlockSize, QWORD qwBlocksDone, QWORD qwBlocksUsed, QWORD qwBlocksTotal, bool bEraseWithNull, char *szFullyBatchMode)
{
BEGIN;
char szTemp[1024];
char szTemp2[1024];
char szTemp3[1024];
time_t timeElapsed, timeRemaining;
QWORD qwBytesPerMin;
float fMinElapsed;
QWORD qwPercent;
QWORD qwTotal;
QWORD qwDone;
if (bEraseWithNull == false)
{
qwPercent = (100 * qwBlocksDone) / qwBlocksUsed;
qwTotal = qwBlockSize * qwBlocksUsed;
}
else
{
qwPercent = (100 * qwBlocksDone) / qwBlocksTotal;
qwTotal = qwBlockSize * qwBlocksTotal;
}
SNPRINTF(szTemp, "%d %%", (int)qwPercent);
newtScaleSet(m_progressRestoring, (int)qwPercent);
newtLabelSetText(m_labelPercent, szTemp);
if (timeStart != 0)
{
qwDone = qwBlockSize * qwBlocksDone;
timeElapsed = time(0) - timeStart;
if (bEraseWithNull)
timeRemaining = (timeElapsed * (qwBlocksTotal - qwBlocksDone)) / qwBlocksDone;
else
timeRemaining = (timeElapsed * (qwBlocksUsed - qwBlocksDone)) / qwBlocksDone;
SNPRINTF(szTemp, i18n("Time elapsed:.....................%s"), formatTime((DWORD)timeElapsed, szTemp2));
newtLabelSetText(m_labelStatsTime, szTemp);
SNPRINTF(szTemp, i18n("Estimated time remaining:.........%s"), formatTime((DWORD)timeRemaining, szTemp2));
newtLabelSetText(m_labelStatsTimeRemaining, szTemp);
fMinElapsed = ((float)timeElapsed) / 60.0;
qwBytesPerMin = (QWORD) (((float)qwDone) / fMinElapsed);
SNPRINTF(szTemp, i18n("Speed:............................%s/min"), formatSize(qwBytesPerMin, szTemp2));
newtLabelSetText(m_labelStatsSpeed, szTemp);
SNPRINTF(szTemp, i18n("Data copied:......................%s / %s"), formatSize(qwDone, szTemp2), formatSize(qwTotal, szTemp3));
newtLabelSetText(m_labelStatsSpace, szTemp);
//option -B gui=no show stats
if ((szFullyBatchMode) && (strlen(szFullyBatchMode)>0))
{
SNPRINTF(szTemp, "stats: %3d%%", (int)qwPercent);
fprintf(stderr,"%-s ",szTemp);
SNPRINTF(szTemp, i18n("%-s %-s"), formatTimeNG((DWORD)timeElapsed, szTemp2), formatTimeNG((DWORD)timeRemaining, szTemp3));
fprintf(stderr,"%-s ",szTemp);
SNPRINTF(szTemp, i18n("%s/min"), formatSizeNG(qwBytesPerMin, szTemp2));
fprintf(stderr,"%-s\n",szTemp);
}
}
newtRefresh();
RETURN;
}
// =======================================================
int CSavingWindow::create(const char *szDevice, const char *szImageFile, const char *szFilesystem, QWORD qwPartSize, COptions options)
{
BEGIN;
char szTemp[1024];
char szTemp2[1024];
SNPRINTF(szTemp, i18n("save partition to image file"));
newtCenteredWindow(78, 20, szTemp);
SNPRINTF(szTemp, i18n("Partition to save:...........%s"), szDevice);
m_labelPartition = newtLabel(1, 0, szTemp);
SNPRINTF(szTemp, i18n("Size of the Partition:.......%s = %llu bytes"), formatSize(qwPartSize, szTemp2), qwPartSize);
m_labelPartitionSize = newtLabel(1, 1, szTemp);
SNPRINTF(szTemp, i18n("Image file to create.........%s"), szImageFile);
m_labelImageFile = newtLabel(1, 2, szTemp);
m_labelImageFileSize = newtLabel(1, 3, "");
m_labelFreeSpace = newtLabel(1, 4, "");
SNPRINTF(szTemp, i18n("Detected file system:........%s"), szFilesystem);
m_labelFS = newtLabel(1, 5, szTemp);
switch (options.dwCompression)
{
case COMPRESS_NONE:
SNPRINTF(szTemp, i18n("Compression level:...........None"));
break;
case COMPRESS_GZIP:
SNPRINTF(szTemp, i18n("Compression level:...........gzip"));
break;
case COMPRESS_BZIP2:
SNPRINTF(szTemp, i18n("Compression level:...........bzip2"));
break;
case COMPRESS_LZO:
SNPRINTF(szTemp, i18n("Compression level:...........lzo"));
break;
}
m_labelCompression = newtLabel(1, 6, szTemp);
// stats
m_labelStatsTime = newtLabel(1, 9, "");
m_labelStatsTimeRemaining = newtLabel(1, 10, "");
m_labelStatsSpeed = newtLabel(1, 11, "");
m_labelStatsSpace = newtLabel(1, 12, "");
m_progressSaving = newtScale(1, 18, 70, 100);
m_labelPercent = newtLabel(72, 18, "");
m_formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(m_formMain, m_labelPartition, m_labelPartitionSize, m_labelImageFile, m_labelImageFileSize, m_labelFreeSpace, m_labelFS, m_labelCompression, NULL);
newtFormAddComponents(m_formMain, m_labelStatsTime, m_labelStatsTimeRemaining, m_labelStatsSpeed, m_labelStatsSpace, NULL);
newtFormAddComponents(m_formMain, m_progressSaving, m_labelPercent, NULL);
newtRefresh();
newtDrawForm(m_formMain);
RETURN_int(0);
}
void play_wav_file(char *filename)
{
char *inwavbuf;
short *current;
short *audioend;
short *audio;
WAVE_HEADER *wav_info;
int wavfd;
int dspfd;
struct stat input_fstat;
size_t interval;
newtComponent vu_1sec;
newtComponent vu_total;
newtComponent wav_length;
newtComponent label_length;
newtComponent mainwaveform;
newtComponent label_1sec;
newtComponent label_total;
newtComponent rf_result;
char labelstr_1sec[10] = "0";
char labelstr_total[10] = "0";
char labelstr_length[10] = "";
short one_sec_max, total_max;
wavfd = open(filename,O_RDONLY,0600);
if (wavfd == -1)
{
printf("Error: open() %s\n",strerror(errno));
exit(1);
}
if (fstat(wavfd,&input_fstat) != 0)
{
printf("Error: fstat() %s\n",strerror(errno));
return;
}
if (input_fstat.st_size < sizeof(WAVE_HEADER))
{
printf("File is not large enough to hold a .wav file header even!\n");
return;
}
inwavbuf = mmap(NULL,input_fstat.st_size,PROT_READ,MAP_SHARED,wavfd,0);
if (inwavbuf == MAP_FAILED)
{
printf("Error: mmap() %s\n",strerror(errno));
exit(1);
}
audio = (short *)validate_wav_header(inwavbuf,0);
current = audio;
if (current == NULL)
{
printf("This program didn't like the wav file\n");
exit(1);
}
wav_info = (WAVE_HEADER *)inwavbuf;
audioend = (short *)((char *)audio + wav_info->nDataBytes);
dspfd = open_dsp(wav_info);
newtCls();
newtDrawRootText(0, 0, filename);
mainwaveform = newtForm(NULL, NULL, NEWT_FLAG_NOF12);
vu_1sec = newtScale(9,5,68,(long long)(SHRT_MAX));
label_1sec = newtLabel(1,5,labelstr_1sec);
wav_length = newtScale(9,3,68,audioend - audio);
label_length = newtLabel(1,3,labelstr_length);
vu_total = newtScale(9,8,68,(long long)(SHRT_MAX));
label_total = newtLabel(1,8,labelstr_total);
newtFormAddComponent(mainwaveform,vu_1sec);
newtFormAddComponent(mainwaveform,vu_total);
newtFormAddComponent(mainwaveform,label_1sec);
newtFormAddComponent(mainwaveform,label_total);
one_sec_max = 0;
total_max = 0;
newtFormWatchFd(mainwaveform,dspfd,NEWT_FD_WRITE);
newtFormAddHotKey(mainwaveform,NEWT_KEY_ENTER);
newtPushHelpLine("Hit Enter to end playing");
newtCenteredWindow(78,10,"now playing .wav file");
newtRefresh();
/* presently every second */
interval = (size_t )((double )wav_info->nSamplesPerSec * interval_s * 2);
while ((current) < audioend)
{
short *endcurrent = current + interval;
if (endcurrent > audioend)
{
endcurrent = audioend;
}
one_sec_max = get_peak_value(current,endcurrent);
newtScaleSet(vu_1sec,one_sec_max);
sprintf(labelstr_1sec,"%1.6f",((float )one_sec_max/ (float )SHRT_MAX));
newtLabelSetText(label_1sec,labelstr_1sec);
newtScaleSet(wav_length,current - audio);
sprintf(labelstr_length,"%4.2f",
((double )(current - audio) / 88200));
newtLabelSetText(label_length,labelstr_length);
if (one_sec_max > total_max)
{
total_max = one_sec_max;
sprintf(labelstr_total,"%1.6f",((float )total_max/ (float )SHRT_MAX));
newtLabelSetText(label_total,labelstr_total);
newtScaleSet(vu_total,total_max);
}
rf_result = newtRunForm(mainwaveform);
if (play_buffer(dspfd,current,endcurrent) == -1)
{
current = audioend;
}
current = endcurrent;
if (rf_result == NULL)
current = audioend;
newtRefresh();
}
newtFormDestroy(mainwaveform);
munmap(inwavbuf,input_fstat.st_size);
close(wavfd);
close(dspfd);
return;
}
/* Small window to change IP and Netmask of some colour */
void changeaddress(char *colour, int *changed_flag)
{
newtComponent networkform;
newtComponent text;
newtComponent ok, cancel;
struct newtExitStruct exitstruct;
char keyvalue[STRING_SIZE];
char addresskey[STRING_SIZE];
char netmaskkey[STRING_SIZE];
char netaddresskey[STRING_SIZE];
newtComponent addresslabel;
newtComponent netmasklabel;
newtComponent addressentry;
newtComponent netmaskentry;
const char *addressresult;
const char *netmaskresult;
char message[STRING_SIZE_LARGE];
int error;
int numLines;
char *tmpstring;
/* Build some key strings. */
sprintf(addresskey, "%s_1_ADDRESS", colour);
sprintf(netmaskkey, "%s_1_NETMASK", colour);
sprintf(netaddresskey, "%s_1_NETADDRESS", colour);
/* workaround gcc warning, there is really 1 %s there */
tmpstring=strdup(gettext("TR_ENTER_THE_IP_ADDRESS_INFORMATION"));
snprintf(message, STRING_SIZE, tmpstring, colour);
free(tmpstring);
text = newtTextboxReflowed(1, 1, message, 68, 0, 0, 0);
numLines = newtTextboxGetNumLines(text);
/* workaround gcc warning, there is really 1 %s there */
tmpstring=strdup(gettext("TR_INTERFACE"));
snprintf(message, STRING_SIZE, tmpstring, colour);
free(tmpstring);
newtCenteredWindow(72, 10 + numLines, message);
networkform = newtForm(NULL, NULL, 0);
newtFormAddComponent(networkform, text);
/* Address */
addresslabel = newtTextbox(2, 2 + numLines, 18, 1, 0);
newtTextboxSetText(addresslabel, gettext("TR_IP_ADDRESS_PROMPT"));
if (!strcmp(colour, "GREEN")) {
/* green only for now */
strcpy(keyvalue, DEFAULT_IP);
}
else {
strcpy(keyvalue, "");
}
find_kv_default(eth_kv, addresskey, keyvalue);
addressentry = newtEntry(20, 2 + numLines, keyvalue, 20, &addressresult, 0);
newtEntrySetFilter(addressentry, filterip, NULL);
newtFormAddComponent(networkform, addresslabel);
newtFormAddComponent(networkform, addressentry);
/* Netmask */
netmasklabel = newtTextbox(2, 3 + numLines, 18, 1, 0);
newtTextboxSetText(netmasklabel, gettext("TR_NETMASK_PROMPT"));
strcpy(keyvalue, DEFAULT_NETMASK);
find_kv_default(eth_kv, netmaskkey, keyvalue);
netmaskentry = newtEntry(20, 3 + numLines, keyvalue, 20, &netmaskresult, 0);
newtEntrySetFilter(netmaskentry, filterip, NULL);
newtFormAddComponent(networkform, netmasklabel);
newtFormAddComponent(networkform, netmaskentry);
ok = newtButton(6, 5 + numLines, gettext("TR_OK"));
/* In case of installer we need a valid address, no turning back */
if (flag_is_state == setupchroot) {
newtFormAddComponent(networkform, ok);
}
else {
cancel = newtButton(26, 5 + numLines, gettext("TR_GO_BACK"));
newtFormAddComponents(networkform, ok, cancel, NULL);
}
newtRefresh();
newtDrawForm(networkform);
do {
error = 0;
newtFormRun(networkform, &exitstruct);
if (exitstruct.u.co == ok) {
strcpy(message, gettext("TR_INVALID_FIELDS"));
if (VALID_IP(addressresult) == FALSE) {
strcat(message, gettext("TR_IP_ADDRESS_CR"));
error = 1;
newtFormSetCurrent(networkform, addressentry);
}
if (VALID_IP(netmaskresult) == FALSE) {
strcat(message, gettext("TR_NETWORK_MASK_CR"));
error = 1;
newtFormSetCurrent(networkform, netmaskentry);
}
// TODO: additional network mask validation
if (error) {
errorbox(message);
}
else {
/* all is well, calc netaddress and store everything */
unsigned long int intaddress;
unsigned long int intnetaddress;
unsigned long int intnetmask;
struct in_addr i_addr;
char *netaddress;
update_kv(ð_kv, addresskey, (char *) addressresult);
update_kv(ð_kv, netmaskkey, (char *) netmaskresult);
/* calculate netaddress */
intaddress = inet_addr(addressresult);
intnetmask = inet_addr(netmaskresult);
intnetaddress = intaddress & intnetmask;
i_addr.s_addr = intnetaddress;
netaddress = inet_ntoa(i_addr);
update_kv(ð_kv, netaddresskey, (char *) netaddress);
changed_config = 1;
*changed_flag = 1;
}
}
}
while (error);
newtFormDestroy(networkform);
newtPopWindow();
}
/**
* Compare biggiefile number @p bigfileno with the filesystem mounted on @p MNT_RESTORING.
* @param bkpinfo The backup information structure. Only used in insist_on_this_cd_number().
* @param bigfileno The biggiefile number (starting from 0) to compare.
* @note This function uses an MD5 checksum.
*/
int compare_a_biggiefile(struct s_bkpinfo *bkpinfo, long bigfileno)
{
FILE *fin;
FILE *fout;
/** needs malloc *******/
char *checksum_ptr;
char *original_cksum_ptr;
char *bigfile_fname_ptr;
char *tmp_ptr;
char *command_ptr;
char *checksum, *original_cksum, *bigfile_fname, *tmp, *command;
char *p;
int i;
int retval = 0;
struct s_filename_and_lstat_info biggiestruct;
malloc_string(checksum);
malloc_string(original_cksum);
malloc_string(bigfile_fname);
malloc_string(tmp);
malloc_string(command);
malloc_string(checksum_ptr);
malloc_string(original_cksum_ptr);
malloc_string(bigfile_fname_ptr);
malloc_string(command_ptr);
malloc_string(tmp_ptr);
/*********************************************************************
* allocate memory clear test sab 16 feb 2003 *
*********************************************************************/
assert(bkpinfo != NULL);
memset(checksum_ptr, '\0', sizeof(checksum));
memset(original_cksum_ptr, '\0', sizeof(original_cksum));
memset(bigfile_fname_ptr, '\0', sizeof(bigfile_fname));
memset(tmp_ptr, '\0', sizeof(tmp));
memset(command_ptr, '\0', sizeof(command));
/** end **/
if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
insist_on_this_cd_number(bkpinfo, (++g_current_media_number));
} else {
sprintf(tmp_ptr,
"No CD's left. No biggiefiles left. No prob, Bob.");
log_msg(2, tmp_ptr);
return (0);
}
}
if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
sprintf(tmp_ptr,
"Cannot open bigfile %ld (%s)'s info file",
bigfileno + 1, bigfile_fname_ptr);
log_to_screen(tmp_ptr);
return (1);
}
fread((void *) &biggiestruct, 1, sizeof(biggiestruct), fin);
paranoid_fclose(fin);
strcpy(checksum_ptr, biggiestruct.checksum);
strcpy(bigfile_fname_ptr, biggiestruct.filename);
log_msg(2, "biggiestruct.filename = %s", biggiestruct.filename);
log_msg(2, "biggiestruct.checksum = %s", biggiestruct.checksum);
sprintf(tmp_ptr, "Comparing %s", bigfile_fname_ptr);
if (!g_text_mode) {
newtDrawRootText(0, 22, tmp_ptr);
newtRefresh();
}
if (!checksum[0]) {
log_msg(2, "Warning - %s has no checksum", bigfile_fname_ptr);
}
if (!strncmp(bigfile_fname_ptr, "/dev/", 5)) {
strcpy(original_cksum_ptr, "IGNORE");
} else {
sprintf(command_ptr,
"md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors.txt",
MNT_RESTORING, bigfile_fname_ptr);
}
log_msg(2, command_ptr);
paranoid_system
("cat /tmp/errors >> /tmp/mondo-restore.log 2> /dev/null");
if (system(command_ptr)) {
log_OS_error("Warning - command failed");
original_cksum[0] = '\0';
return (1);
} else {
if (!(fin = fopen("/tmp/md5sum.txt", "r"))) {
log_msg(2,
"Unable to open /tmp/md5sum.txt; can't get live checksum");
original_cksum[0] = '\0';
return (1);
} else {
fgets(original_cksum_ptr, MAX_STR_LEN - 1, fin);
paranoid_fclose(fin);
for (i = strlen(original_cksum_ptr);
i > 0 && original_cksum[i - 1] < 32; i--);
original_cksum[i] = '\0';
p = (char *) strchr(original_cksum_ptr, ' ');
if (p) {
*p = '\0';
}
}
}
sprintf(tmp_ptr, "bigfile #%ld ('%s') ", bigfileno + 1,
bigfile_fname_ptr);
if (!strcmp(checksum_ptr, original_cksum_ptr) != 0) {
strcat(tmp_ptr, " ... OK");
} else {
strcat(tmp_ptr, "... changed");
retval++;
}
log_msg(1, tmp_ptr);
if (retval) {
if (!(fout = fopen("/tmp/changed.txt", "a"))) {
fatal_error("Cannot openout changed.txt");
}
fprintf(fout, "%s\n", bigfile_fname_ptr);
paranoid_fclose(fout);
}
paranoid_free(original_cksum_ptr);
paranoid_free(original_cksum);
paranoid_free(bigfile_fname_ptr);
paranoid_free(bigfile_fname);
paranoid_free(checksum_ptr);
paranoid_free(checksum);
paranoid_free(command_ptr);
paranoid_free(command);
paranoid_free(tmp_ptr);
paranoid_free(tmp);
return (retval);
}
