static int
clustdiffer(cl_t cl, cl_t *cp1, cl_t *cp2, u_int fatnum)
{
if (*cp1 == CLUST_FREE || *cp1 >= CLUST_RSRVD) {
if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
if ((*cp1 != CLUST_FREE && *cp1 < CLUST_BAD
&& *cp2 != CLUST_FREE && *cp2 < CLUST_BAD)
|| (*cp1 > CLUST_BAD && *cp2 > CLUST_BAD)) {
pwarn("Cluster %u is marked %s with different indicators\n",
cl, rsrvdcltype(*cp1));
if (ask(1, "Fix")) {
*cp2 = *cp1;
return FSFATMOD;
}
return FSFATAL;
}
pwarn("Cluster %u is marked %s in FAT 0, %s in FAT %u\n",
cl, rsrvdcltype(*cp1), rsrvdcltype(*cp2), fatnum);
if (ask(0, "Use FAT 0's entry")) {
*cp2 = *cp1;
return FSFATMOD;
}
if (ask(0, "Use FAT %u's entry", fatnum)) {
*cp1 = *cp2;
return FSFATMOD;
}
return FSFATAL;
}
pwarn("Cluster %u is marked %s in FAT 0, but continues with cluster %u in FAT %d\n",
cl, rsrvdcltype(*cp1), *cp2, fatnum);
if (ask(0, "Use continuation from FAT %u", fatnum)) {
*cp1 = *cp2;
return FSFATMOD;
}
if (ask(0, "Use mark from FAT 0")) {
*cp2 = *cp1;
return FSFATMOD;
}
return FSFATAL;
}
if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
pwarn("Cluster %u continues with cluster %u in FAT 0, but is marked %s in FAT %u\n",
cl, *cp1, rsrvdcltype(*cp2), fatnum);
if (ask(0, "Use continuation from FAT 0")) {
*cp2 = *cp1;
return FSFATMOD;
}
if (ask(0, "Use mark from FAT %d", fatnum)) {
*cp1 = *cp2;
return FSFATMOD;
}
return FSERROR;
}
pwarn("Cluster %u continues with cluster %u in FAT 0, but with cluster %u in FAT %u\n",
cl, *cp1, *cp2, fatnum);
if (ask(0, "Use continuation from FAT 0")) {
*cp2 = *cp1;
return FSFATMOD;
}
if (ask(0, "Use continuation from FAT %u", fatnum)) {
*cp1 = *cp2;
return FSFATMOD;
}
return FSERROR;
}
int
checkfilesys(const char *filename)
{
int dosfs;
struct bootblock boot;
struct fatEntry *fat = NULL;
int i, finish_dosdirsection=0;
int mod = 0;
int ret = FSCK_EXIT_CHECK_FAILED;
rdonly = alwaysno;
if (!preen)
printf("** %s", filename);
dosfs = open(filename, rdonly ? O_RDONLY : O_RDWR, 0);
if (dosfs < 0 && !rdonly) {
dosfs = open(filename, O_RDONLY, 0);
if (dosfs >= 0)
pwarn(" (NO WRITE)\n");
else if (!preen)
printf("\n");
rdonly = 1;
} else if (!preen)
printf("\n");
if (dosfs < 0) {
perr("Can't open `%s'", filename);
return FSCK_EXIT_CHECK_FAILED;
}
if (readboot(dosfs, &boot) != FSOK) {
close(dosfs);
printf("\n");
return FSCK_EXIT_CHECK_FAILED;
}
if (!preen) {
if (boot.ValidFat < 0)
printf("** Phase 1 - Read and Compare FATs\n");
else
printf("** Phase 1 - Read FAT\n");
}
mod |= readfat(dosfs, &boot, boot.ValidFat >= 0 ? boot.ValidFat : 0, &fat);
if (mod & FSFATAL) {
close(dosfs);
return FSCK_EXIT_CHECK_FAILED;
}
if (boot.ValidFat < 0)
for (i = 1; i < boot.FATs; i++) {
struct fatEntry *currentFat;
mod |= readfat(dosfs, &boot, i, ¤tFat);
if (mod & FSFATAL)
goto out;
mod |= comparefat(&boot, fat, currentFat, i);
free(currentFat);
if (mod & FSFATAL)
goto out;
}
if (!preen)
printf("** Phase 2 - Check Cluster Chains\n");
mod |= checkfat(&boot, fat);
if (mod & FSFATAL)
goto out;
/* delay writing FATs */
if (!preen)
printf("** Phase 3 - Checking Directories\n");
mod |= resetDosDirSection(&boot, fat);
finish_dosdirsection = 1;
if (mod & FSFATAL)
goto out;
/* delay writing FATs */
mod |= handleDirTree(dosfs, &boot, fat);
if (mod & FSFATAL)
goto out;
if (!preen)
printf("** Phase 4 - Checking for Lost Files\n");
mod |= checklost(dosfs, &boot, fat);
if (mod & FSFATAL)
goto out;
/* now write the FATs */
if (mod & FSFATMOD) {
if (ask(1, "Update FATs")) {
mod |= writefat(dosfs, &boot, fat, mod & FSFIXFAT);
if (mod & FSFATAL)
goto out;
} else
mod |= FSERROR;
}
if (boot.NumBad)
pwarn("%d files, %d free (%d clusters), %d bad (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree,
boot.NumBad * boot.ClusterSize / 1024, boot.NumBad);
else
pwarn("%d files, %d free (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree);
if (mod && (mod & FSERROR) == 0) {
if (mod & FSDIRTY) {
if (ask(1, "MARK FILE SYSTEM CLEAN") == 0)
mod &= ~FSDIRTY;
if (mod & FSDIRTY) {
pwarn("MARKING FILE SYSTEM CLEAN\n");
mod |= writefat(dosfs, &boot, fat, 1);
} else {
pwarn("\n***** FILE SYSTEM IS LEFT MARKED AS DIRTY *****\n");
mod |= FSERROR; /* file system not clean */
}
}
}
if (mod & (FSFATAL | FSERROR))
goto out;
ret = FSCK_EXIT_OK;
out:
if (finish_dosdirsection)
finishDosDirSection();
free(fat);
close(dosfs);
if (mod & (FSFATMOD|FSDIRMOD))
pwarn("\n***** FILE SYSTEM WAS MODIFIED *****\n");
return ret;
}
/*
* Read a FAT and decode it into internal format
*/
int
readfat(int fs, struct bootblock *boot, u_int no, struct fatEntry **fp)
{
struct fatEntry *fat;
u_char *buffer, *p;
cl_t cl;
int ret = FSOK;
size_t len;
boot->NumFree = boot->NumBad = 0;
if (!_readfat(fs, boot, no, &buffer))
return FSFATAL;
fat = malloc(len = boot->NumClusters * sizeof(struct fatEntry));
if (fat == NULL) {
perr("No space for FAT clusters (%zu)", len);
free(buffer);
return FSFATAL;
}
(void)memset(fat, 0, len);
if (buffer[0] != boot->bpbMedia
|| buffer[1] != 0xff || buffer[2] != 0xff
|| (boot->ClustMask == CLUST16_MASK && buffer[3] != 0xff)
|| (boot->ClustMask == CLUST32_MASK
&& ((buffer[3]&0x0f) != 0x0f
|| buffer[4] != 0xff || buffer[5] != 0xff
|| buffer[6] != 0xff || (buffer[7]&0x0f) != 0x0f))) {
/* Windows 95 OSR2 (and possibly any later) changes
* the FAT signature to 0xXXffff7f for FAT16 and to
* 0xXXffff0fffffff07 for FAT32 upon boot, to know that the
* file system is dirty if it doesn't reboot cleanly.
* Check this special condition before errorring out.
*/
if (buffer[0] == boot->bpbMedia && buffer[1] == 0xff
&& buffer[2] == 0xff
&& ((boot->ClustMask == CLUST16_MASK && buffer[3] == 0x7f)
|| (boot->ClustMask == CLUST32_MASK
&& buffer[3] == 0x0f && buffer[4] == 0xff
&& buffer[5] == 0xff && buffer[6] == 0xff
&& buffer[7] == 0x07)))
ret |= FSDIRTY;
else {
/* just some odd byte sequence in FAT */
switch (boot->ClustMask) {
case CLUST32_MASK:
pwarn("%s (%02x%02x%02x%02x%02x%02x%02x%02x)\n",
"FAT starts with odd byte sequence",
buffer[0], buffer[1], buffer[2], buffer[3],
buffer[4], buffer[5], buffer[6], buffer[7]);
break;
case CLUST16_MASK:
pwarn("%s (%02x%02x%02x%02x)\n",
"FAT starts with odd byte sequence",
buffer[0], buffer[1], buffer[2], buffer[3]);
break;
default:
pwarn("%s (%02x%02x%02x)\n",
"FAT starts with odd byte sequence",
buffer[0], buffer[1], buffer[2]);
break;
}
if (ask(1, "Correct"))
ret |= FSFIXFAT;
}
}
switch (boot->ClustMask) {
case CLUST32_MASK:
p = buffer + 8;
break;
case CLUST16_MASK:
p = buffer + 4;
break;
default:
p = buffer + 3;
break;
}
for (cl = CLUST_FIRST; cl < boot->NumClusters;) {
switch (boot->ClustMask) {
case CLUST32_MASK:
fat[cl].next = p[0] + (p[1] << 8)
+ (p[2] << 16) + (p[3] << 24);
fat[cl].next &= boot->ClustMask;
ret |= checkclnum(boot, no, cl, &fat[cl].next);
cl++;
p += 4;
break;
case CLUST16_MASK:
fat[cl].next = p[0] + (p[1] << 8);
ret |= checkclnum(boot, no, cl, &fat[cl].next);
cl++;
p += 2;
break;
default:
fat[cl].next = (p[0] + (p[1] << 8)) & 0x0fff;
ret |= checkclnum(boot, no, cl, &fat[cl].next);
cl++;
if (cl >= boot->NumClusters)
break;
fat[cl].next = ((p[1] >> 4) + (p[2] << 4)) & 0x0fff;
ret |= checkclnum(boot, no, cl, &fat[cl].next);
cl++;
p += 3;
break;
}
}
free(buffer);
if (ret & FSFATAL) {
free(fat);
*fp = NULL;
} else
*fp = fat;
return ret;
}
int
checkfilesys(const char *fname)
{
int dosfs;
struct bootblock boot;
struct fatEntry *fat = NULL;
int i;
int mod = 0;
int quiet = 0;
int skip_fat_compare = 0;
rdonly = alwaysno;
if (!quiet)
printf("** %s", fname);
dosfs = open(fname, rdonly ? O_RDONLY : O_RDWR, 0);
if (dosfs < 0 && !rdonly) {
dosfs = open(fname, O_RDONLY, 0);
if (dosfs >= 0)
pwarn(" (NO WRITE)\n");
else if (!quiet)
printf("\n");
rdonly = 1;
} else if (!quiet)
printf("\n");
if (dosfs < 0) {
perror("Can't open");
return 8;
}
if (readboot(dosfs, &boot) == FSFATAL) {
close(dosfs);
printf("\n");
return 8;
}
if (skipclean && preen && checkdirty(dosfs, &boot)) {
printf("%s: ", fname);
printf("FILESYSTEM CLEAN; SKIPPING CHECKS\n");
close(dosfs);
return 0;
}
if (((boot.FATsecs * boot.BytesPerSec) / 1024) > FAT_COMPARE_MAX_KB)
skip_fat_compare = 1;
if (!quiet) {
if (skip_fat_compare)
printf("** Phase 1 - Read FAT (compare skipped)\n");
else if (boot.ValidFat < 0)
printf("** Phase 1 - Read and Compare FATs\n");
else
printf("** Phase 1 - Read FAT\n");
}
mod |= readfat(dosfs, &boot, boot.ValidFat >= 0 ? boot.ValidFat : 0, &fat);
if (mod & FSERROR) {
printf("FSERROR after readfat()\n");
}
if (mod & FSFATAL) {
printf("\nFatal error during readfat()\n");
close(dosfs);
return 8;
}
if (!skip_fat_compare && boot.ValidFat < 0)
for (i = 1; i < (int)boot.FATs; i++) {
struct fatEntry *currentFat;
mod |= readfat(dosfs, &boot, i, ¤tFat);
if (mod & FSFATAL) {
printf("Fatal error during readfat() for comparison\n");
free(fat);
(void)close(dosfs);
return 8;
}
mod |= comparefat(&boot, fat, currentFat, i);
free(currentFat);
if (mod & FSFATAL) {
printf("Fatal error during FAT comparison\n");
free(fat);
(void)close(dosfs);
return 8;
}
}
if (!quiet)
printf("** Phase 2 - Check Cluster Chains\n");
mod |= checkfat(&boot, fat);
if (mod & FSERROR) {
printf("FSERROR after checkfat()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during FAT check\n");
free(fat);
(void)close(dosfs);
return 8;
}
/* delay writing FATs */
if (!quiet)
printf("** Phase 3 - Checking Directories\n");
mod |= resetDosDirSection(&boot, fat);
if (mod & FSERROR) {
printf("FSERROR after resetDosDirSection()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during resetDosDirSection()\n");
free(fat);
close(dosfs);
return 8;
}
/* delay writing FATs */
mod |= handleDirTree(dosfs, &boot, fat);
if (mod & FSERROR) {
printf("FSERROR after handleDirTree()\n");
/* try to recovery again */
mod &= ~FSERROR;
mod |= handleDirTree(dosfs, &boot, fat);
}
if (mod & FSFATAL) {
printf("Fatal error during handleDirTree()\n");
finishDosDirSection();
free(fat);
close(dosfs);
return 8;
}
if (!quiet)
printf("** Phase 4 - Checking for Lost Files\n");
mod |= checklost(dosfs, &boot, fat);
if (mod & FSERROR) {
printf("FSERROR after checklost()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during checklost()\n");
finishDosDirSection();
free(fat);
(void)close(dosfs);
return 8;
}
/* now write the FATs */
if (mod & FSFATMOD) {
if (ask(1, "Update FATs")) {
mod |= writefat(dosfs, &boot, fat, mod & FSFIXFAT);
if (mod & FSFATAL) {
printf("Fatal error during writefat()\n");
finishDosDirSection();
free(fat);
(void)close(dosfs);
return 8;
}
} else
mod |= FSERROR;
}
if (boot.NumBad)
pwarn("%d files, %d free (%d clusters), %d bad (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree,
boot.NumBad * boot.ClusterSize / 1024, boot.NumBad);
else
pwarn("%d files, %d free (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree);
if (mod && (mod & FSERROR) == 0) {
if (mod & FSDIRTY) {
if (ask(1, "MARK FILE SYSTEM CLEAN") == 0)
mod &= ~FSDIRTY;
if (mod & FSDIRTY) {
pwarn("MARKING FILE SYSTEM CLEAN\n");
mod |= writefat(dosfs, &boot, fat, 1);
} else {
pwarn("\n***** FILE SYSTEM IS LEFT MARKED AS DIRTY *****\n");
mod |= FSERROR; /* file system not clean */
}
}
}
finishDosDirSection();
free(fat);
(void)close(dosfs);
if (mod & FSFATAL) {
pwarn("\n***** FSFATAL *****\n");
return 8;
}
if (mod & FSERROR) {
pwarn("\n***** FSERROR *****\n");
return 8;
}
if (mod) {
pwarn("\n***** FILE SYSTEM WAS MODIFIED *****\n");
return 4;
}
return 0;
}
int sumRange(int i, int j) {
return ask (j + 1) - ask (i);
}
int write_cabrillo(void)
{
extern char* cabrillo;
extern char logfile[];
extern char exchange[];
extern char call[];
char* cab_dfltfile;
struct cabrillo_desc *cabdesc;
char cabrillo_tmp_name[80];
char buffer[4000] = "";
FILE *fp1, *fp2;
struct qso_t *qso;
if (cabrillo == NULL) {
info("Missing CABRILLO= keyword (see man page)");
sleep(2);
return(1);
}
/* Try to read cabrillo format first from local directory.
* Try also in default data dir if not found.
*/
cabdesc = read_cabrillo_format("cabrillo.fmt", cabrillo);
if (!cabdesc) {
cab_dfltfile = g_strconcat(PACKAGE_DATA_DIR, G_DIR_SEPARATOR_S,
"cabrillo.fmt", NULL);
cabdesc = read_cabrillo_format(cab_dfltfile, cabrillo);
g_free(cab_dfltfile);
}
if (!cabdesc) {
info("Cabrillo format specification not found!");
sleep(2);
return(2);
}
/* open logfile and create a cabrillo file */
strcpy(cabrillo_tmp_name, call);
g_strstrip(cabrillo_tmp_name); /* drop \n */
strcat(cabrillo_tmp_name, ".cbr");
if ((fp1 = fopen(logfile, "r")) == NULL) {
info("Can't open logfile.");
sleep(2);
free_cabfmt( cabdesc );
return (1);
}
if ((fp2 = fopen(cabrillo_tmp_name, "w")) == NULL) {
info("Can't create cabrillo file.");
sleep(2);
free_cabfmt( cabdesc );
fclose(fp1); //added by F8CFE
return (2);
}
/* ask for exchange and header information */
ask(buffer, "Your exchange (e.g. State, province, age etc... (# if serial number)): ");
strncpy(exchange, buffer, 10);
getsummary( fp2 );
info("Writing cabrillo file");
while ((qso = get_next_record(fp1))) {
prepare_line(qso, cabdesc, buffer);
if (strlen(buffer) > 5)
fputs(buffer, fp2);
free_qso(qso);
}
fclose(fp1);
fputs("END-OF-LOG:\n", fp2);
fclose(fp2);
free_cabfmt( cabdesc );
return 0;
}
/* Never should get here */
}
static int
match_process_uid(pid_t pid, uid_t uid)
{
char buf[128];
uid_t puid;
FILE *f;
int re = -1;
snprintf (buf, sizeof buf, PROC_BASE "/%d/status", pid);
if (!(f = fopen (buf, "r")))
return 0;
while (fgets(buf, sizeof buf, f))
{
if (sscanf (buf, "Uid:\t%d", &puid))
{
re = uid==puid;
break;
}
}
fclose(f);
if (re==-1)
{
fprintf(stderr, _("Cannot get UID from process status\n"));
exit(1);
}
return re;
}
static regex_t *
build_regexp_list(int names, char **namelist)
{
int i;
regex_t *reglist;
int flag = REG_EXTENDED|REG_NOSUB;
if (!(reglist = malloc (sizeof (regex_t) * names)))
{
perror ("malloc");
exit (1);
}
if (ignore_case)
flag |= REG_ICASE;
for (i = 0; i < names; i++)
{
if (regcomp(®list[i], namelist[i], flag) != 0)
{
fprintf(stderr, _("Bad regular expression: %s\n"), namelist[i]);
exit (1);
}
}
return reglist;
}
#ifdef WITH_SELINUX
static int
kill_all(int signal, int names, char **namelist, struct passwd *pwent,
regex_t *scontext )
#else /*WITH_SELINUX*/
static int
kill_all (int signal, int names, char **namelist, struct passwd *pwent)
#endif /*WITH_SELINUX*/
{
DIR *dir;
struct dirent *de;
FILE *file;
struct stat st, sts[MAX_NAMES];
int *name_len = NULL;
char *path, comm[COMM_LEN];
char *command_buf;
char *command;
pid_t *pid_table, pid, self, *pid_killed;
pid_t *pgids;
int i, j, okay, length, got_long, error;
int pids, max_pids, pids_killed;
unsigned long found;
regex_t *reglist = NULL;;
#ifdef WITH_SELINUX
security_context_t lcontext=NULL;
#endif /*WITH_SELINUX*/
if (names && reg)
reglist = build_regexp_list(names, namelist);
else if (names)
{
if (!(name_len = malloc (sizeof (int) * names)))
{
perror ("malloc");
exit (1);
}
for (i = 0; i < names; i++)
{
if (!strchr (namelist[i], '/'))
{
sts[i].st_dev = 0;
name_len[i] = strlen (namelist[i]);
}
else if (stat (namelist[i], &sts[i]) < 0)
{
perror (namelist[i]);
exit (1);
}
}
}
self = getpid ();
found = 0;
if (!(dir = opendir (PROC_BASE)))
{
perror (PROC_BASE);
exit (1);
}
max_pids = 256;
pid_table = malloc (max_pids * sizeof (pid_t));
if (!pid_table)
{
perror ("malloc");
exit (1);
}
pids = 0;
while ( (de = readdir (dir)) != NULL)
{
if (!(pid = (pid_t) atoi (de->d_name)) || pid == self)
continue;
if (pids == max_pids)
{
if (!(pid_table = realloc (pid_table, 2 * pids * sizeof (pid_t))))
{
perror ("realloc");
exit (1);
}
max_pids *= 2;
}
pid_table[pids++] = pid;
}
(void) closedir (dir);
pids_killed = 0;
pid_killed = malloc (max_pids * sizeof (pid_t));
if (!pid_killed)
{
perror ("malloc");
exit (1);
}
if (!process_group)
pgids = NULL; /* silence gcc */
else
{
pgids = malloc (pids * sizeof (pid_t));
if (!pgids)
{
perror ("malloc");
exit (1);
}
}
for (i = 0; i < pids; i++)
{
pid_t id;
int found_name = -1;
/* match by UID */
if (pwent && match_process_uid(pid_table[i], pwent->pw_uid)==0)
continue;
#ifdef WITH_SELINUX
/* match by SELinux context */
if (scontext)
{
if (getpidcon(pid_table[i], &lcontext) < 0)
continue;
if (regexec(scontext, lcontext, 0, NULL, 0) != 0) {
freecon(lcontext);
continue;
}
freecon(lcontext);
}
#endif /*WITH_SELINUX*/
/* load process name */
if (asprintf (&path, PROC_BASE "/%d/stat", pid_table[i]) < 0)
continue;
if (!(file = fopen (path, "r")))
{
free (path);
continue;
}
free (path);
okay = fscanf (file, "%*d (%15[^)]", comm) == 1;
(void) fclose (file);
if (!okay)
continue;
got_long = 0;
command = NULL; /* make gcc happy */
length = strlen (comm);
if (length == COMM_LEN - 1)
{
if (asprintf (&path, PROC_BASE "/%d/cmdline", pid_table[i]) < 0)
continue;
if (!(file = fopen (path, "r"))) {
free (path);
continue;
}
free (path);
while (1) {
/* look for actual command so we skip over initial "sh" if any */
char *p;
int cmd_size = 128;
command_buf = (char *)malloc (cmd_size);
if (!command_buf)
exit (1);
/* 'cmdline' has arguments separated by nulls */
for (p=command_buf; ; p++) {
int c;
if (p == (command_buf + cmd_size))
{
int cur_size = cmd_size;
cmd_size *= 2;
command_buf = (char *)realloc(command_buf, cmd_size);
if (!command_buf)
exit (1);
p = command_buf + cur_size;
}
c = fgetc(file);
if (c == EOF || c == '\0') {
*p = '\0';
break;
} else {
*p = c;
}
}
if (strlen(command_buf) == 0) {
okay = 0;
break;
}
p = strrchr(command_buf,'/');
p = p ? p+1 : command_buf;
if (strncmp(p, comm, COMM_LEN-1) == 0) {
okay = 1;
command = p;
break;
}
}
(void) fclose(file);
if (exact && !okay)
{
if (verbose)
fprintf (stderr, _("skipping partial match %s(%d)\n"), comm,
pid_table[i]);
continue;
}
got_long = okay;
}
/* mach by process name */
for (j = 0; j < names; j++)
{
if (reg)
{
if (regexec (®list[j], got_long ? command : comm, 0, NULL, 0) != 0)
continue;
}
else /* non-regex */
{
if (!sts[j].st_dev)
{
if (length != COMM_LEN - 1 || name_len[j] < COMM_LEN - 1)
{
if (ignore_case == 1)
{
if (strcasecmp (namelist[j], comm))
continue;
}
else
{
if (strcmp(namelist[j], comm))
continue;
}
}
else if (got_long ? strcmp (namelist[j], command) :
strncmp (namelist[j], comm, COMM_LEN - 1))
continue;
}
else
{
int ok = 1;
if (asprintf (&path, PROC_BASE "/%d/exe", pid_table[i]) < 0)
continue;
if (stat (path, &st) < 0)
ok = 0;
else if (sts[j].st_dev != st.st_dev ||
sts[j].st_ino != st.st_ino)
{
/* maybe the binary has been modified and std[j].st_ino
* is not reliable anymore. We need to compare paths.
*/
char linkbuf[PATH_MAX];
if (readlink(path, linkbuf, sizeof(linkbuf)) <= 0 ||
strcmp(namelist[j], linkbuf))
ok = 0;
}
free(path);
if (!ok)
continue;
}
} /* non-regex */
found_name = j;
break;
}
if (names && found_name==-1)
continue; /* match by process name faild */
/* check for process group */
if (!process_group)
id = pid_table[i];
else
{
int j;
id = getpgid (pid_table[i]);
pgids[i] = id;
if (id < 0)
{
fprintf (stderr, "getpgid(%d): %s\n", pid_table[i],
strerror (errno));
}
for (j = 0; j < i; j++)
if (pgids[j] == id)
break;
if (j < i)
continue;
}
if (interactive && !ask (comm, id, signal))
continue;
if (pidof)
{
if (found)
putchar (' ');
printf ("%d", id);
found |= 1 << (found_name >= 0 ? found_name : 0);
}
else if (kill (process_group ? -id : id, signal) >= 0)
{
if (verbose)
fprintf (stderr, _("Killed %s(%s%d) with signal %d\n"), got_long ? command :
comm, process_group ? "pgid " : "", id, signal);
if (found_name >= 0)
/* mark item of namelist */
found |= 1 << found_name;
pid_killed[pids_killed++] = id;
}
else if (errno != ESRCH || interactive)
fprintf (stderr, "%s(%d): %s\n", got_long ? command :
comm, id, strerror (errno));
}
if (!quiet && !pidof)
for (i = 0; i < names; i++)
if (!(found & (1 << i)))
fprintf (stderr, _("%s: no process killed\n"), namelist[i]);
if (pidof)
putchar ('\n');
if (names)
/* killall returns a zero return code if at least one process has
* been killed for each listed command. */
error = found == ((1 << (names - 1)) | ((1 << (names - 1)) - 1)) ? 0 : 1;
else
/* in nameless mode killall returns a zero return code if at least
* one process has killed */
error = pids_killed ? 0 : 1;
/*
* We scan all (supposedly) killed processes every second to detect dead
* processes as soon as possible in order to limit problems of race with
* PID re-use.
*/
while (pids_killed && wait_until_dead)
{
for (i = 0; i < pids_killed;)
{
if (kill (process_group ? -pid_killed[i] : pid_killed[i], 0) < 0 &&
errno == ESRCH)
{
pid_killed[i] = pid_killed[--pids_killed];
continue;
}
i++;
}
sleep (1); /* wait a bit longer */
}
return error;
}
uval
test_os(uval argc, uval argv[])
{
uval ret[1];
sval rc;
uval r3 = argv[0];
uval r4 = argv[1];
uval ofd;
const uval slot = 0x1;
uval schedvals[3];
sval rot;
uval nchunks = 0;
uval ofd_size;
uval i = 0;
argc = argc;
rrupts_off();
/* Setting up the IPC structures */
#ifndef RELOADER
ret[0] = aipc_config(msgHandler);
if (ret[0] != H_Success) {
hprintf("Failed create: %ld\n", ret[0]);
}
#endif
if (r3 == ~0UL) {
/* we../src/bin/mambo-sti -n have cloned ourselves */
hputs("hello world.. this is slave\n");
rc = hcall_get_lpid(ret);
assert(rc == H_Success, "hcall_get_lpid() failed\n");
hprintf("I am partition ID %ld\n", ret[0]);
yield(0);
}
hputs("hello world.. this is controller\n");
rc = hcall_get_lpid(ret);
assert(rc == H_Success, "hcall_get_lpid() failed\n");
ofd = ofd_devtree_init(r4, &ofd_size);
ofd_bootargs(ofd, default_bootargs, sizeof (default_bootargs));
pgalloc_init(&pa, (uval)_end, 0, pinfo[1].mem[0].size, LOG_PGSIZE);
if (ofd) {
set_pages_used(&pa, (uval)ofd, ofd_size);
}
init_allocator(&pa);
rrupts_on();
struct mem_range *mem = &pinfo[1].mem[0];
uval max_addr = mem[0].size;
while (i < MAX_MEM_RANGES &&
mem[i].size != INVALID_MEM_RANGE) {
nchunks += mem[i].size / CHUNK_SIZE;
max_addr = mem[i].addr + mem[i].size;
++i;
}
pgalloc_init(&logical_pa, ~((uval)0), 0, max_addr, LOG_PGSIZE);
set_pages_used(&logical_pa, 0, CHUNK_SIZE);
uval curr = CHUNK_SIZE;
i = 0;
while (i < MAX_MEM_RANGES &&
mem[i].size != INVALID_MEM_RANGE) {
if (curr < mem[i].addr) {
set_pages_used(&logical_pa, curr,
mem[i].addr - curr);
curr = mem[i].addr;
}
if (curr < mem[i].addr + mem[i].size) {
free_pages(&logical_pa, curr,
mem[i].addr + mem[i].size - curr);
curr = mem[i].addr + mem[i].size;
}
if (curr == mem[i].addr + mem[i].size) {
++i;
}
}
assert(nchunks >= 1, "not enough chunks to create an LPAR\n");
hprintf("setting my sched slot to 0x%0lx\n", slot);
rot = hcall_set_sched_params(schedvals, H_SELF_LPID,
THIS_CPU, slot, 0);
assert(rot >= 0, "set sched failed\n");
hprintf("Scheduler controller: rot: "
"%ld (0x%016lx, 0x%016lx 0x%016lx)\n",
rot, schedvals[0], schedvals[1], schedvals[2]);
curslots = schedvals[0];
#ifdef RELOADER
reload_image(image_names[0], ofd);
#endif
for (i = 0; i < MAX_MANAGED_PARTITIONS; ++i) {
curslots &= ~partitions[i].slot;
partitions[i].active = 0;
partitions[i].init_mem = 0;
partitions[i].init_mem_size = 0;
partitions[i].lpid = -1;
partitions[i].vterm = 0;
partitions[i].slot = 0;
partitions[i].msgrcv = 0;
partitions[i].name = NULL;
}
ask(r3, ofd);
assert(0, "controller: Should never get here\n");
return 0;
}
void auto_create_bookmark(void)
{
listitem *li;
int a;
bool auto_create, had_passwd = false;
bool update = false;
if(gvAutoBookmark == 0 && gvAutoBookmarkUpdate == 0)
return;
if(!ftp_loggedin() || gvSighupReceived)
return;
auto_create = (gvAutoBookmark == 1);
/* check if bookmark already exists */
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, ftp->url);
if(li) {
if(!should_update_bookmark((url_t *)li->data))
return;
/* bookmark already exist, update it */
if(gvAutoBookmarkUpdate == 2) {
a = ask(ASKYES|ASKNO, ASKYES,
_("Do you want to update the bookmark for this site?"));
if(a == ASKNO)
return;
}
update = true;
auto_create = true;
had_passwd = (((url_t *)li->data)->password != 0);
}
if(gvAutoBookmark == 2 && !auto_create) {
a = ask(ASKYES|ASKNO, ASKYES,
_("Do you want to create a bookmark for this site?"));
if(a == ASKNO)
return;
create_bookmark(0);
} else { /* auto autobookmark... */
url_t *url;
char *a;
url = url_clone(ftp->url);
a = guess_alias(ftp->url);
url_setalias(url, a);
free(a);
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, url);
if(li) {
/* bookmark already exist, overwrite it */
while(true) {
url_t *xurl = (url_t *)li->data;
if(xurl->alias && (strcmp(xurl->alias, url->alias) == 0)
&& (strcmp(xurl->hostname, url->hostname) != 0))
{
/* create a new version of the alias, since guessed alias
* already exists but for another host
*/
char *par;
update = false;
par = strrchr(url->alias, '(');
if(par == 0)
asprintf(&a, "%s(2)", url->alias);
else {
int ver;
*par = 0;
ver = atoi(par + 1);
asprintf(&a, "%s(%d)", url->alias, ver + 1);
}
url_setalias(url, a);
free(a);
} else {
update = true;
had_passwd = (xurl->password != 0);
break;
}
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, url);
if(li == 0)
break;
}
if(li) /* overwrite bookmark (ie, delete old and create a new) */
list_delitem(gvBookmarks, li);
if(!url_isanon(url) && gvAutoBookmarkSavePasswd == false
&& !had_passwd)
url_setpassword(url, 0);
} else {
if(!url_isanon(url) && gvAutoBookmarkSavePasswd == false)
url_setpassword(url, 0);
}
create_the_bookmark(url);
if(!gvAutoBookmarkSilent) {
if(update)
printf(_("updated bookmark %s\n"), url->alias);
else
printf(_("created bookmark %s\n"), url->alias);
}
}
}
int
main(int argc, char *argv[])
{
bool newrc, already;
int rcfirst = 0; /* first message to print (from .rc) */
int rcback = 0; /* amount to back off of rcfirst */
int firstmsg = 0, nextmsg = 0, lastmsg = 0;
int blast = 0;
struct stat buf; /* stat to check access of bounds */
FILE *bounds;
char *cp;
#ifdef UNBUFFERED
setbuf(stdout, NULL);
#endif
setlocale(LC_ALL, "");
time(&t);
if (setuid(uid = getuid()) != 0)
err(1, "setuid failed");
ruptible = (signal(SIGINT, SIG_IGN) == SIG_DFL);
if (ruptible)
signal(SIGINT, SIG_DFL);
argc--, argv++;
while (argc > 0) {
if (isdigit(argv[0][0])) { /* starting message # */
rcfirst = atoi(argv[0]);
}
else if (isdigit(argv[0][1])) { /* backward offset */
rcback = atoi( &( argv[0][1] ) );
}
else {
ptr = *argv;
while (*ptr) switch (*ptr++) {
case '-':
break;
case 'c':
if (uid != SUPERUSER && uid != DAEMON)
errx(1,
"only the super-user can use the c flag");
clean = YES;
break;
case 'f': /* silently */
hush = YES;
break;
case 'h': /* headers only */
hdrs = YES;
break;
case 'l': /* local msgs only */
locomode = YES;
break;
case 'o': /* option to save last message */
lastcmd = YES;
break;
case 'p': /* pipe thru 'more' during long msgs */
use_pager = YES;
break;
case 'q': /* query only */
qopt = YES;
break;
case 's': /* sending TO msgs */
send_msg = YES;
break;
default:
usage();
}
}
argc--, argv++;
}
/*
* determine current message bounds
*/
snprintf(fname, sizeof(fname), "%s/%s", _PATH_MSGS, BOUNDS);
/*
* Test access rights to the bounds file
* This can be a little tricky. if(send_msg), then
* we will create it. We assume that if(send_msg),
* then you have write permission there.
* Else, it better be there, or we bail.
*/
if (send_msg != YES) {
if (stat(fname, &buf) < 0) {
if (hush != YES) {
err(errno, "%s", fname);
} else {
exit(1);
}
}
}
bounds = fopen(fname, "r");
if (bounds != NULL) {
fscanf(bounds, "%d %d\n", &firstmsg, &lastmsg);
fclose(bounds);
blast = lastmsg; /* save upper bound */
}
if (clean)
keep = t - (rcback? rcback : NDAYS) DAYS;
if (clean || bounds == NULL) { /* relocate message bounds */
struct dirent *dp;
struct stat stbuf;
bool seenany = NO;
DIR *dirp;
dirp = opendir(_PATH_MSGS);
if (dirp == NULL)
err(errno, "%s", _PATH_MSGS);
firstmsg = 32767;
lastmsg = 0;
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)){
cp = dp->d_name;
int i = 0;
if (dp->d_ino == 0)
continue;
if (dp->d_namlen == 0)
continue;
if (clean)
snprintf(inbuf, sizeof(inbuf), "%s/%s", _PATH_MSGS, cp);
while (isdigit(*cp))
i = i * 10 + *cp++ - '0';
if (*cp)
continue; /* not a message! */
if (clean) {
if (stat(inbuf, &stbuf) != 0)
continue;
if (stbuf.st_mtime < keep
&& stbuf.st_mode&S_IWRITE) {
unlink(inbuf);
continue;
}
}
if (i > lastmsg)
lastmsg = i;
if (i < firstmsg)
firstmsg = i;
seenany = YES;
}
closedir(dirp);
if (!seenany) {
if (blast != 0) /* never lower the upper bound! */
lastmsg = blast;
firstmsg = lastmsg + 1;
}
else if (blast > lastmsg)
lastmsg = blast;
if (!send_msg) {
bounds = fopen(fname, "w");
if (bounds == NULL)
err(errno, "%s", fname);
chmod(fname, CMODE);
fprintf(bounds, "%d %d\n", firstmsg, lastmsg);
fclose(bounds);
}
}
if (send_msg) {
/*
* Send mode - place msgs in _PATH_MSGS
*/
bounds = fopen(fname, "w");
if (bounds == NULL)
err(errno, "%s", fname);
nextmsg = lastmsg + 1;
snprintf(fname, sizeof(fname), "%s/%d", _PATH_MSGS, nextmsg);
newmsg = fopen(fname, "w");
if (newmsg == NULL)
err(errno, "%s", fname);
chmod(fname, CMODE);
fprintf(bounds, "%d %d\n", firstmsg, nextmsg);
fclose(bounds);
sending = YES;
if (ruptible)
signal(SIGINT, onintr);
if (isatty(fileno(stdin))) {
ptr = getpwuid(uid)->pw_name;
printf("Message %d:\nFrom %s %sSubject: ",
nextmsg, ptr, ctime(&t));
fflush(stdout);
fgets(inbuf, sizeof inbuf, stdin);
putchar('\n');
fflush(stdout);
fprintf(newmsg, "From %s %sSubject: %s\n",
ptr, ctime(&t), inbuf);
blankline = seensubj = YES;
}
else
blankline = seensubj = NO;
for (;;) {
fgets(inbuf, sizeof inbuf, stdin);
if (feof(stdin) || ferror(stdin))
break;
blankline = (blankline || (inbuf[0] == '\n'));
seensubj = (seensubj || (!blankline && (strncmp(inbuf, "Subj", 4) == 0)));
fputs(inbuf, newmsg);
}
#ifdef OBJECT
if (!seensubj) {
printf("NOTICE: Messages should have a Subject field!\n");
#ifdef REJECT
unlink(fname);
#endif
exit(1);
}
#endif
exit(ferror(stdin));
}
if (clean)
exit(0);
/*
* prepare to display messages
*/
totty = (isatty(fileno(stdout)) != 0);
use_pager = use_pager && totty;
if ((cp = getenv("HOME")) == NULL || *cp == '\0') {
fprintf(stderr, "Error, no home directory!\n");
exit(1);
}
snprintf(fname, sizeof(fname), "%s/%s", cp, MSGSRC);
msgsrc = fopen(fname, "r");
if (msgsrc) {
newrc = NO;
fscanf(msgsrc, "%d\n", &nextmsg);
fclose(msgsrc);
if (nextmsg > lastmsg+1) {
printf("Warning: bounds have been reset (%d, %d)\n",
firstmsg, lastmsg);
truncate(fname, (off_t)0);
newrc = YES;
}
else if (!rcfirst)
rcfirst = nextmsg - rcback;
}
else
newrc = YES;
msgsrc = fopen(fname, "r+");
if (msgsrc == NULL)
msgsrc = fopen(fname, "w");
if (msgsrc == NULL)
err(errno, "%s", fname);
if (rcfirst) {
if (rcfirst > lastmsg+1) {
printf("Warning: the last message is number %d.\n",
lastmsg);
rcfirst = nextmsg;
}
if (rcfirst > firstmsg)
firstmsg = rcfirst; /* don't set below first msg */
}
if (newrc) {
nextmsg = firstmsg;
rewind(msgsrc);
fprintf(msgsrc, "%d\n", nextmsg);
fflush(msgsrc);
}
#ifdef V7
if (totty) {
struct winsize win;
if (ioctl(fileno(stdout), TIOCGWINSZ, &win) != -1)
Lpp = win.ws_row;
if (Lpp <= 0) {
if (tgetent(inbuf, getenv("TERM")) <= 0
|| (Lpp = tgetnum("li")) <= 0) {
Lpp = NLINES;
}
}
}
#endif
Lpp -= 6; /* for headers, etc. */
already = NO;
prevmsg = firstmsg;
printing = YES;
if (ruptible)
signal(SIGINT, onintr);
/*
* Main program loop
*/
for (msg = firstmsg; msg <= lastmsg; msg++) {
snprintf(fname, sizeof(fname), "%s/%d", _PATH_MSGS, msg);
newmsg = fopen(fname, "r");
if (newmsg == NULL)
continue;
gfrsub(newmsg); /* get From and Subject fields */
if (locomode && !local) {
fclose(newmsg);
continue;
}
if (qopt) { /* This has to be located here */
printf("There are new messages.\n");
exit(0);
}
if (already && !hdrs)
putchar('\n');
/*
* Print header
*/
if (totty)
signal(SIGTSTP, onsusp);
(void) setjmp(tstpbuf);
already = YES;
nlines = 2;
if (seenfrom) {
printf("Message %d:\nFrom %s %s", msg, from, date);
nlines++;
}
if (seensubj) {
printf("Subject: %s", subj);
nlines++;
}
else {
if (seenfrom) {
putchar('\n');
nlines++;
}
while (nlines < 6
&& fgets(inbuf, sizeof inbuf, newmsg)
&& inbuf[0] != '\n') {
fputs(inbuf, stdout);
nlines++;
}
}
lct = linecnt(newmsg);
if (lct)
printf("(%d%sline%s) ", lct, seensubj? " " : " more ",
(lct == 1) ? "" : "s");
if (hdrs) {
printf("\n-----\n");
fclose(newmsg);
continue;
}
/*
* Ask user for command
*/
if (totty)
ask(lct? MORE : (msg==lastmsg? NOMORE : NEXT));
else
inbuf[0] = 'y';
if (totty)
signal(SIGTSTP, SIG_DFL);
cmnd:
in = inbuf;
switch (*in) {
case 'x':
/* FALLTHROUGH */
case 'X':
exit(0);
/* NOTREACHED */
case 'q':
/* FALLTHROUGH */
case 'Q':
quitit = YES;
printf("--Postponed--\n");
exit(0);
/* NOTREACHED */
case 'n':
/* FALLTHROUGH */
case 'N':
if (msg >= nextmsg) sep = "Flushed";
prevmsg = msg;
break;
case 'p':
/* FALLTHROUGH */
case 'P':
use_pager = (*in++ == 'p');
/* FALLTHROUGH */
case '\n':
/* FALLTHROUGH */
case 'y':
default:
if (*in == '-') {
msg = prevmsg-1;
sep = "replay";
break;
}
if (isdigit(*in)) {
msg = next(in);
sep = in;
break;
}
prmesg(nlines + lct + (seensubj? 1 : 0));
prevmsg = msg;
}
printf("--%s--\n", sep);
sep = "-";
if (msg >= nextmsg) {
nextmsg = msg + 1;
rewind(msgsrc);
fprintf(msgsrc, "%d\n", nextmsg);
fflush(msgsrc);
}
if (newmsg)
fclose(newmsg);
if (quitit)
break;
}
/*
* Make sure .rc file gets updated
*/
if (--msg >= nextmsg) {
nextmsg = msg + 1;
rewind(msgsrc);
fprintf(msgsrc, "%d\n", nextmsg);
fflush(msgsrc);
}
if (already && !quitit && lastcmd && totty) {
/*
* save or reply to last message?
*/
msg = prevmsg;
ask(NOMORE);
if (inbuf[0] == '-' || isdigit(inbuf[0]))
goto cmnd;
}
if (!(already || hush || qopt))
printf("No new messages.\n");
exit(0);
/* NOTREACHED */
}
static void
ask(const char *prompt)
{
char inch;
int n, cmsg, fd;
off_t oldpos;
FILE *cpfrom, *cpto;
printf("%s ", prompt);
fflush(stdout);
intrpflg = NO;
(void) fgets(inbuf, sizeof inbuf, stdin);
if ((n = strlen(inbuf)) > 0 && inbuf[n - 1] == '\n')
inbuf[n - 1] = '\0';
if (intrpflg)
inbuf[0] = 'x';
/*
* Handle 'mail' and 'save' here.
*/
if ((inch = inbuf[0]) == 's' || inch == 'm') {
if (inbuf[1] == '-')
cmsg = prevmsg;
else if (isdigit(inbuf[1]))
cmsg = atoi(&inbuf[1]);
else
cmsg = msg;
snprintf(fname, sizeof(fname), "%s/%d", _PATH_MSGS, cmsg);
oldpos = ftello(newmsg);
cpfrom = fopen(fname, "r");
if (!cpfrom) {
printf("Message %d not found\n", cmsg);
ask (prompt);
return;
}
if (inch == 's') {
in = nxtfld(inbuf);
if (*in) {
for (n=0; in[n] > ' '; n++) { /* sizeof fname? */
fname[n] = in[n];
}
fname[n] = '\0';
}
else
strcpy(fname, "Messages");
fd = open(fname, O_RDWR|O_EXCL|O_CREAT|O_APPEND);
}
else {
strcpy(fname, _PATH_TMP);
fd = mkstemp(fname);
if (fd != -1) {
snprintf(cmdbuf, sizeof(cmdbuf), _PATH_MAIL,
fname);
mailing = YES;
}
}
if (fd == -1 || (cpto = fdopen(fd, "a")) == NULL) {
if (fd != -1)
close(fd);
warn("%s", fname);
mailing = NO;
fseeko(newmsg, oldpos, SEEK_SET);
ask(prompt);
return;
}
while ((n = fread(inbuf, 1, sizeof inbuf, cpfrom)))
fwrite(inbuf, 1, n, cpto);
fclose(cpfrom);
fclose(cpto);
fseeko(newmsg, oldpos, SEEK_SET);/* reposition current message */
if (inch == 's')
printf("Message %d saved in \"%s\"\n", cmsg, fname);
else {
system(cmdbuf);
unlink(fname);
mailing = NO;
}
ask(prompt);
}
}
void load_ltaglist(bool showerr, bool always_autoload,
const char *alt_filename)
{
FILE *fp;
char *f, *e = 0;
unsigned n = 0;
int c;
char tmp[4096];
if(gvLoadTaglist == 0 && !always_autoload)
return;
if(alt_filename == 0)
if (asprintf(&e, "%s/taglist.local", gvWorkingDirectory) == -1)
{
fprintf(stderr, _("Failed to allocate memory.\n"));
return;
}
f = tilde_expand_home(alt_filename ? alt_filename : e, gvLocalHomeDir);
free(e);
fp = fopen(f, "r");
if(!fp) {
if(showerr) {
if(alt_filename)
perror(alt_filename);
else
fprintf(stderr, _("No saved local taglist\n"));
}
free(f);
return;
}
if(gvLoadTaglist == 2 && !always_autoload) {
c = ask(ASKYES|ASKNO, ASKYES,
_("Found saved local taglist, load it now?"));
if(c == ASKNO) {
fclose(fp);
return;
}
} /* else gvLoadTaglist == 1 == yes */
if(fgets(tmp, 4096, fp) != 0) {
strip_trailing_chars(tmp, "\n\r");
if(strcasecmp(tmp, "[yafc taglist]") != 0) {
fprintf(stderr, "Not a Yafc taglist file: %s\n", f);
fclose(fp);
return;
}
}
while(true) {
if(fgets(tmp, 4096, fp) == 0)
break;
strip_trailing_chars(tmp, "\r\n");
if(tmp[0] == 0)
continue;
list_additem(gvLocalTagList, xstrdup(tmp));
n++;
}
if(n)
fprintf(stderr, "Loaded %u files from saved local taglist %s\n", n, f);
fclose(fp);
if(alt_filename == 0)
unlink(f);
free(f);
}
void Game::the_game()
{
for (int i = 0; i < 13 * players; i++)
{
cout << "\nGRACZ " << current_player << endl << endl;
dice_cup.throw_dice();
score_sheet++; //sumowanie punktow
show_score_sheet();
//ponowne rzuty
int additional_throws = 0;
do {
if (ask() == 49)
{
if (score_sheet.save_points(false))
break;
else
continue;
}
else
{
if (dice_cup.re_throw_dice())
{
additional_throws++;
show_score_sheet();
if (additional_throws == 2)
{
score_sheet.save_points(true);
break;
}
}
else
{
score_sheet.draw();
}
}
} while (1);
if (current_player == players)
current_player = 1;
else
current_player++;
}
score_sheet++;
cout << endl;
show_score_sheet();
score_sheet.who_win();
}
int ask(int x,int a,int b,int c){
if(a==b)return v[x];
int mid=(a+b)>>1;
return c<=mid?ask(l[x],a,mid,c):ask(r[x],mid+1,b,c);
}
/*
* Check a complete FAT in-memory for crosslinks
*/
int
checkfat(struct bootblock *boot, struct fatEntry *fat)
{
cl_t head, p, h, n;
u_int len;
int ret = 0;
int conf;
/*
* pass 1: figure out the cluster chains.
*/
for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
/* find next untravelled chain */
if (fat[head].head != 0 /* cluster already belongs to some chain */
|| fat[head].next == CLUST_FREE
|| fat[head].next == CLUST_BAD)
continue; /* skip it. */
/* follow the chain and mark all clusters on the way */
for (len = 0, p = head;
p >= CLUST_FIRST && p < boot->NumClusters &&
fat[p].head != head;
p = fat[p].next) {
fat[p].head = head;
len++;
}
/* the head record gets the length */
fat[head].length = fat[head].next == CLUST_FREE ? 0 : len;
}
/*
* pass 2: check for crosslinked chains (we couldn't do this in pass 1 because
* we didn't know the real start of the chain then - would have treated partial
* chains as interlinked with their main chain)
*/
for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
/* find next untravelled chain */
if (fat[head].head != head)
continue;
/* follow the chain to its end (hopefully) */
for (len = fat[head].length, p = head;
(n = fat[p].next) >= CLUST_FIRST && n < boot->NumClusters;
p = n)
if (fat[n].head != head || len-- < 2)
break;
if (n >= CLUST_EOFS)
continue;
if (n == CLUST_FREE || n >= CLUST_RSRVD) {
pwarn("Cluster chain starting at %u ends with cluster marked %s\n",
head, rsrvdcltype(n));
clear:
ret |= tryclear(boot, fat, head, &fat[p].next);
continue;
}
if (n < CLUST_FIRST || n >= boot->NumClusters) {
pwarn("Cluster chain starting at %u ends with cluster out of range (%u)\n",
head, n);
goto clear;
}
if (head == fat[n].head) {
pwarn("Cluster chain starting at %u loops at cluster %u\n",
head, p);
goto clear;
}
pwarn("Cluster chains starting at %u and %u are linked at cluster %u\n",
head, fat[n].head, n);
conf = tryclear(boot, fat, head, &fat[p].next);
if (ask(0, "Clear chain starting at %u", h = fat[n].head)) {
if (conf == FSERROR) {
/*
* Transfer the common chain to the one not cleared above.
*/
for (p = n;
p >= CLUST_FIRST && p < boot->NumClusters;
p = fat[p].next) {
if (h != fat[p].head) {
/*
* Have to reexamine this chain.
*/
head--;
break;
}
fat[p].head = head;
}
}
clearchain(boot, fat, h);
conf |= FSFATMOD;
}
ret |= conf;
}
return ret;
}
static bool zwritefile(char *fname)
{
char bakname[PATHMAX + 1];
struct mark smark;
struct stat sbuf;
int nlink = 1, rc;
bool bak = false;
/* If the file existed, check to see if it has been modified. */
if (Curbuff->mtime && stat(fname, &sbuf) == 0) {
if (sbuf.st_mtime > Curbuff->mtime) {
strconcat(PawStr, PAWSTRLEN,
"WARNING: ", lastpart(fname),
" has been modified. Overwrite? ", NULL);
if (ask(PawStr) != YES)
return false;
}
#ifndef __QNXNTO__
nlink = sbuf.st_nlink;
#endif
}
#if HUGE_FILES
if (Bbuff->fd != -1) {
strconcat(PawStr, PAWSTRLEN,
"WARNING: huge file ", lastpart(fname),
" not yet read. Are you sure? ", NULL);
if (ask(PawStr) != YES)
return false;
}
#endif
/* check for links and handle backup file */
make_bakname(bakname, sizeof(bakname), fname);
if (nlink > 1) {
strconcat(PawStr, PAWSTRLEN, "WARNING: ", lastpart(fname),
" is linked. Preserve? ", NULL);
switch (ask(PawStr)) {
case YES:
if (VAR(VBACKUP))
bak = cp(fname, bakname);
break;
case NO:
if (VAR(VBACKUP))
bak = rename(fname, bakname);
else
unlink(fname); /* break link */
break;
case ABORT:
return false;
}
} else if (VAR(VBACKUP))
bak = rename(fname, bakname);
bmrktopnt(Bbuff, &smark);
rc = bwritefile(Bbuff, fname, file_mode());
bpnttomrk(Bbuff, &smark);
if (rc) {
if (stat(fname, &sbuf) == 0)
Curbuff->mtime = sbuf.st_mtime;
else
Curbuff->mtime = -1;
clrpaw();
} else {
if (errno == EACCES)
error("File is read only.");
else
error("Unable to write file.");
if (bak) {
if (sbuf.st_nlink) {
cp(bakname, fname);
unlink(bakname);
} else
rename(bakname, fname);
}
}
return rc;
}
int main(int argc, char * argv[])
{
#ifdef DEBUG
open_debug();
#endif
init_static_control_simple();
void ask(addr_t addr)
{
char str[DEFAULT_TRANSFER];
struct args args = { .log_addr = addr, .log_len = DEFAULT_TRANSFER, .phys_addr = (unsigned long)str, .direction = direct_read };
root_strategy->ops[0][opcode_trans]((void*)root_strategy, &args, "");
if(args.success) {
printf("%s", str);
}
}
bool cmd(addr_t addr, char * str, char * param)
{
struct args args = { .log_addr = addr, .log_len = strlen(str), .phys_addr = (unsigned long)str, .direction = direct_write };
root_strategy->ops[0][opcode_trans]((void*)root_strategy, &args, param);
return args.success;
}
addr_t boot(char * str, char * param)
{
struct args args = { .log_len = DEFAULT_TRANSFER, .reader = FALSE, .exclu = TRUE, .action = action_wait, .melt = TRUE, .try_len = DEFAULT_TRANSFER, .op_code = opcode_gadr };
root_strategy->ops[0][opcode_gadr]((void*)root_strategy, &args, param);
if(!args.success) {
printf("!!!!! gadrcreateget failed\n");
exit(-1);
}
args.log_len = strlen(str);
args.phys_addr = (unsigned long)str;
args.direction = direct_write;
args.op_code = opcode_trans;
root_strategy->ops[0][opcode_trans]((void*)root_strategy, &args, param);
if(!args.success) {
printf("!!!!! trans '%s' failed\n", str);
exit(-1);
}
return args.log_addr;
}
char str[256];
addr_t control = DEFAULT_TRANSFER;
cmd(control, "output:=control\n", "");
// basic level
#if 0
addr_t dev = boot("brick:=device_dummy_linux\n output:=out", "testfile");
sprintf(str, "brick:=buffer_dummy_linux\n \n connect dev:=%llx:out\n output:=out {\n", dev);
addr_t buffer = boot(str, "");
sprintf(str, "brick:=map_simple\n connect in:=%llx:out\noutput:=out", buffer);
#else
sprintf(str, "brick:=map_dummy\n output:=out{\n");
#endif
addr_t map = boot(str, "");
sprintf(str, "brick:=adapt_meta\n connect in:=%llx:out\n output:=out\n", map);
addr_t meta = boot(str, "");
#if 0
sprintf(str, "brick:=spy_trace\n connect in:=%llx:out\n output:=out\n", meta);
meta = boot(str, "spylog");
#endif
// create root hook
cmd(0, "output:=_root", "");
cmd(meta, "connect hook:=0:_root", "");
// strategy level
sprintf(str, "brick:=fs_simple\n connect strat:=%llx:control\n output:=control{\n", control);
addr_t fs = boot(str, "_root");
// testing
sprintf(str, "brick:=bench_fs\n connect strat:=%llx:control\n", fs);
addr_t bench = boot(str, "");
#if 1
ask(0);
ask(DEFAULT_TRANSFER);
ask(0x3000);
#endif
printf("================== STARTING BENCH ================\n");
cmd(bench, "output:=dummy", "1000");
printf("================== END BENCH ================\n");
#ifdef MOVE_COUNT
extern void print_counts(void);
print_counts();
printf("------------------------------------\n");
printf("_makespace: shortcuts: %d count1: %d count2: %d\n", count_0, count_1, count_2);
printf("creates (count_c1) = %d, triggering creates (count_c2) = %d\n", count_c1, count_c2);
#endif
cmd(meta, "brick/=adapt_meta", "");
cmd(map, "brick/=map_dummy", "");
#ifdef DEBUG
close_debug();
#endif
return 0;
}
/*main function*/
int main()
{
int a = 0, b = 0, c = 0;
char input[length], color[length], correct = 'F', Q = 'T';
char player[50];
char victory,ans;
int x = 0;
do{
print_score();
num++;
if(x>0)/*only after one trial, then ask.*/
{
ans = ask();
if(ans == 'N')
{
return 0;
}
else if( ans == 'Y')
{
printf("\tEnjoy the game. :)\n\n");
system ("pause");
system ("cls");
}
else
{
return 0;
}
}
x=0;
welcome();
Info();
printf("\n\n");
RandGen(color);
printf("\n");
options();
do
{
options1(x);
for( a=0; a<length; a++)
{
ans = scan(input,a, color);
if(ans == 'Q')
{
return 0;
}
else if(ans == 'I')
{
x--;
break;
}
}
x++;
victory = check1(input, color);
check2(input, color);
if(victory == 'T')
{
part[num].score = x;
congrat();
break;
}
c++;
if(c == 20)
{
part[num].score = 9999;
break;
}
}while(c < 21);
}while(b = 1);
}
/*
The ADIF function has been written according ADIF v1.00 specifications
as shown on http://www.adif.org
LZ3NY
*/
int write_adif(void)
{
extern char logfile[];
extern char exchange[];
extern char whichcontest[];
extern int exchange_serial;
extern char modem_mode[];
char buf[181] = "";
char buffer[181] = "";
char standardexchange[70] = "";
char adif_tmp_name[40] = "";
char adif_tmp_call[13] = "";
char adif_tmp_str[2] = "";
char adif_year_check[3] = "";
char adif_rcvd_num[16] = "";
char resultat[16];
char adif_tmp_rr[5] = "";
double freq;
char freq_buf[16];
int adif_mode_dep = 0;
FILE *fp1, *fp2;
if ((fp1 = fopen(logfile, "r")) == NULL) {
info("Opening logfile not possible.");
sleep(2);
return (1);
}
strcpy(adif_tmp_name, whichcontest);
strcat(adif_tmp_name, ".adi");
if ((fp2 = fopen(adif_tmp_name, "w")) == NULL) {
info("Opening ADIF file not possible.");
sleep(2);
fclose(fp1); //added by F8CFE
return (2);
}
if (strlen(exchange) > 0)
strcpy(standardexchange, exchange);
/* in case using write_adif() without write_cabrillo() before
* just ask for the needed information */
if ((strlen(standardexchange) == 0) && (exchange_serial != 1)) {
ask(buffer, "Your exchange (e.g. State, province, age etc... (# if serial number)): ");
strncpy(standardexchange, buffer, 10);
}
info("Writing ADIF file");
/* write header */
fputs
("################################################################################\n",
fp2);
fputs
("# ADIF v1.00 data file exported by TLF\n",
fp2);
fputs
("# according to specifications on http://www.adif.org\n",
fp2);
fputs("#\n", fp2);
fputs
("################################################################################\n",
fp2);
fputs("<adif_ver:4>1.00\n<eoh>\n", fp2);
while (fgets(buf, sizeof(buf), fp1)) {
buffer[0] = '\0';
if ((buf[0] != ';') && ((buf[0] != ' ') || (buf[1] != ' '))
&& (buf[0] != '#') && (buf[0] != '\n') && (buf[0] != '\r')) {
/* CALLSIGN */
strcat(buffer, "<CALL:");
strncpy(adif_tmp_call, buf + 29, 12);
strcpy(adif_tmp_call, g_strstrip(adif_tmp_call));
snprintf(resultat, sizeof(resultat), "%zd",
strlen(adif_tmp_call));
strcat(buffer, resultat);
strcat(buffer, ">");
strcat(buffer, adif_tmp_call);
/* BAND */
if (buf[1] == '6')
strcat(buffer, "<BAND:4>160M");
else if (buf[1] == '8')
strcat(buffer, "<BAND:3>80M");
else if (buf[1] == '4')
strcat(buffer, "<BAND:3>40M");
else if (buf[1] == '3')
strcat(buffer, "<BAND:3>30M");
else if (buf[1] == '2')
strcat(buffer, "<BAND:3>20M");
else if (buf[1] == '1' && buf[2] == '5')
strcat(buffer, "<BAND:3>15M");
else if (buf[1] == '1' && buf[2] == '7')
strcat(buffer, "<BAND:3>17M");
else if (buf[1] == '1' && buf[2] == '2')
strcat(buffer, "<BAND:3>12M");
else if (buf[1] == '1' && buf[2] == '0')
strcat(buffer, "<BAND:3>10M");
/* FREQ if available */
if (strlen(buf) > 81) {
freq = atof(buf+80);
freq_buf[0] = '\0';
if ((freq > 1799.) && (freq < 10000.)) {
sprintf(freq_buf, "<FREQ:6>%.4f", freq/1000.);
} else if (freq >= 10000.) {
sprintf(freq_buf, "<FREQ:7>%.4f", freq/1000.);
}
strcat(buffer, freq_buf);
}
/* QSO MODE */
if (buf[3] == 'C')
strcat(buffer, "<MODE:2>CW");
else if (buf[3] == 'S')
strcat(buffer, "<MODE:3>SSB");
else if (strcmp(modem_mode, "RTTY") == 0)
strcat(buffer, "<MODE:4>RTTY");
else
/* \todo DIGI is no allowed mode */
strcat(buffer, "<MODE:4>DIGI");
/* QSO_DATE */
/* Y2K :) */
adif_year_check[0] = '\0';
strncpy(adif_year_check, buf + 14, 2);
if (atoi(adif_year_check) <= 70)
strcat(buffer, "<QSO_DATE:8>20");
else
strcat(buffer, "<QSO_DATE:8>19");
/* year */
strncat(buffer, buf + 14, 2);
/*month */
if (buf[10] == 'J' && buf[11] == 'a')
strcat(buffer, "01");
if (buf[10] == 'F')
strcat(buffer, "02");
if (buf[10] == 'M' && buf[12] == 'r')
strcat(buffer, "03");
if (buf[10] == 'A' && buf[12] == 'r')
strcat(buffer, "04");
if (buf[10] == 'M' && buf[12] == 'y')
strcat(buffer, "05");
if (buf[10] == 'J' && buf[11] == 'u' && buf[12] == 'n')
strcat(buffer, "06");
if (buf[10] == 'J' && buf[12] == 'l')
strcat(buffer, "07");
if (buf[10] == 'A' && buf[12] == 'g')
strcat(buffer, "08");
if (buf[10] == 'S')
strcat(buffer, "09");
if (buf[10] == 'O')
strcat(buffer, "10");
if (buf[10] == 'N')
strcat(buffer, "11");
if (buf[10] == 'D')
strcat(buffer, "12");
/*date */
strncat(buffer, buf + 7, 2);
/* TIME_ON */
strcat(buffer, "<TIME_ON:4>");
strncat(buffer, buf + 17, 2);
strncat(buffer, buf + 20, 2);
/* RS(T) flag */
if (buf[3] == 'S') /* check for SSB */
adif_mode_dep = 2;
else
adif_mode_dep = 3;
/* RST_SENT */
strcat(buffer, "<RST_SENT:");
adif_tmp_str[1] = '\0'; /* PA0R 02/10/2003 */
adif_tmp_str[0] = adif_mode_dep + 48;
strcat(buffer, adif_tmp_str);
strcat(buffer, ">");
strncat(buffer, buf + 44, adif_mode_dep);
/* STX - sent contest number */
strcat(buffer, "<STX:");
if ((exchange_serial == 1) || (standardexchange[0] == '#')) {
strcat(buffer, "4>");
strncat(buffer, buf + 23, 4);
} else {
snprintf(resultat, sizeof(resultat), "%zd",
strlen(standardexchange));
strcat(buffer, resultat);
strcat(buffer, ">");
strcat(buffer, g_strstrip(standardexchange));
}
/* RST_RCVD */
strncpy(adif_tmp_rr, buf + 49, 4);
strcpy(adif_tmp_rr, g_strstrip(adif_tmp_rr));
strcat(buffer, "<RST_RCVD:");
snprintf(resultat, sizeof(resultat), "%zd",
strlen(adif_tmp_rr));
strcat(buffer, resultat);
strcat(buffer, ">");
strncat(buffer, buf + 49, adif_mode_dep);
/* SRX - received contest number */
strncpy(adif_rcvd_num, buf + 54, 14);
strcpy(adif_rcvd_num, g_strstrip(adif_rcvd_num));
snprintf(resultat, sizeof(resultat), "%zd",
strlen(adif_rcvd_num));
strcat(buffer, "<SRX:");
strcat(buffer, resultat);
strcat(buffer, ">");
if (strcmp(buf + 54, " ") != 0)
strcat(buffer, adif_rcvd_num);
/* <EOR> */
strcat(buffer, "<eor>\n"); //end of ADIF row
fputs(buffer, fp2);
}
} // end fgets() loop
fclose(fp1);
fclose(fp2);
return (0);
} // end write_adif
static bool
plan_a(const char *filename)
{
int ifd, statfailed;
char *p, *s;
struct stat filestat;
ptrdiff_t sz;
size_t i;
size_t iline, lines_allocated;
#ifdef DEBUGGING
if (debug & 8)
return false;
#endif
if (filename == NULL || *filename == '\0')
return false;
statfailed = stat(filename, &filestat);
if (statfailed && ok_to_create_file) {
if (verbose)
say("(Creating file %s...)\n", filename);
/*
* in check_patch case, we still display `Creating file' even
* though we're not. The rule is that -C should be as similar
* to normal patch behavior as possible
*/
if (check_only)
return true;
makedirs(filename, true);
close(creat(filename, 0666));
statfailed = stat(filename, &filestat);
}
if (statfailed)
fatal("can't find %s\n", filename);
filemode = filestat.st_mode;
if (!S_ISREG(filemode))
fatal("%s is not a normal file--can't patch\n", filename);
if ((uint64_t)filestat.st_size > SIZE_MAX) {
say("block too large to mmap\n");
return false;
}
i_size = (size_t)filestat.st_size;
if (out_of_mem) {
set_hunkmax(); /* make sure dynamic arrays are allocated */
out_of_mem = false;
return false; /* force plan b because plan a bombed */
}
if ((ifd = open(filename, O_RDONLY)) < 0)
pfatal("can't open file %s", filename);
if (i_size) {
i_womp = mmap(NULL, i_size, PROT_READ, MAP_PRIVATE, ifd, 0);
if (i_womp == MAP_FAILED) {
perror("mmap failed");
i_womp = NULL;
close(ifd);
return false;
}
} else {
i_womp = NULL;
}
close(ifd);
if (i_size)
madvise(i_womp, i_size, MADV_SEQUENTIAL);
/* estimate the number of lines */
lines_allocated = i_size / 25;
if (lines_allocated < 100)
lines_allocated = 100;
if (!reallocate_lines(&lines_allocated))
return false;
/* now scan the buffer and build pointer array */
iline = 1;
i_ptr[iline] = i_womp;
/* test for NUL too, to maintain the behavior of the original code */
for (s = i_womp, i = 0; i < i_size && *s != '\0'; s++, i++) {
if (*s == '\n') {
if (iline == lines_allocated) {
if (!reallocate_lines(&lines_allocated))
return false;
}
/* these are NOT NUL terminated */
i_ptr[++iline] = s + 1;
}
}
/* if the last line contains no EOL, append one */
if (i_size > 0 && i_womp[i_size - 1] != '\n') {
last_line_missing_eol = true;
/* fix last line */
sz = s - i_ptr[iline];
p = malloc(sz + 1);
if (p == NULL) {
free(i_ptr);
i_ptr = NULL;
munmap(i_womp, i_size);
i_womp = NULL;
return false;
}
memcpy(p, i_ptr[iline], sz);
p[sz] = '\n';
i_ptr[iline] = p;
/* count the extra line and make it point to some valid mem */
i_ptr[++iline] = empty_line;
} else
last_line_missing_eol = false;
input_lines = iline - 1;
/* now check for revision, if any */
if (revision != NULL) {
if (i_womp == NULL || !rev_in_string(i_womp)) {
if (force) {
if (verbose)
say("Warning: this file doesn't appear "
"to be the %s version--patching anyway.\n",
revision);
} else if (batch) {
fatal("this file doesn't appear to be the "
"%s version--aborting.\n",
revision);
} else {
ask("This file doesn't appear to be the "
"%s version--patch anyway? [n] ",
revision);
if (*buf != 'y')
fatal("aborted\n");
}
} else if (verbose)
say("Good. This file appears to be the %s version.\n",
revision);
}
return true; /* plan a will work */
}
int main(int argc, char** argv)
{
// in case generate shared memory to pointer area_addr
// address work area
char *area_addr = NULL;
// work area
register int area_id=0;
// ptr to current state entry
register struct state *pState=NULL;
// SIGSEGV state hold area func ptr
void (*savefunc) ();
// action to be performed
register int action=0;
while(0 != (action = ask())){
if(0 < nap){
fprintf(stderr, "currently attached segments");
fprintf(stderr, " shm_id address\n");
fprintf(stderr, "------- ---------\n");
pState = &attached_segments[nap+1];
while(--pState != attached_segments){
fprintf(stderr, "%6d", pState->shm_id);
fprintf(stderr, "%#11x", (unsigned int) pState->shm_addr);
fprintf(stderr, " Read%s\n", (pState->shm_flag & SHM_RDONLY) ? "-Only" : "/Write");
}
fprintf(stderr, "\n");
}else{
fprintf(stderr, "no segments are currently attached\n");
switch(action){
case 1:
// 1 - verify that there is space for another attach
if(nap == MAXnap){
fprintf(stderr, "this simple example will only allow %d attached segments\n", MAXnap);
break;
}
// get the arguments, make the call, report the result and update the current state array
pState = &attached_segments[++nap];
readnumber(&pState->shm_id, ID_DIGITS, "enter shm_id of segment to attach:");
readstring(pState->shm_addr, ADDR_DIGITS, "enter shm_addr");
fprintf(stderr, "meaningful shm_flag vlaues are:\n");
fprintf(stderr, "1\tSHM_RDONLY (%d)\n", SHM_RDONLY);
fprintf(stderr, "2\tSHM_RND (%d)\n", SHM_RND);
unsigned int select=0;
unsigned int askagain=0;
do{
askagain=0;
readdigit(&select, "select a shm_flag");
switch(select){
case 1:
puts("SHM_RDONLY");
pState->shm_flag = SHM_RDONLY;
break;
case 2:
puts("SHM_RND");
pState->shm_flag = SHM_RND;
break;
default:
puts("wrong input - try again");
askagain = 1;
break;
}
}while(askagain);
fprintf(stderr, "now attach the segment - shmat(%d, %#x, %#o)\n"
, pState->shm_id, (unsigned int) pState->shm_addr, pState->shm_flag);
if(0 > (pState->shm_addr = shmat(pState->shm_id, pState->shm_addr, pState->shm_flag))){
perror("shmat() failed");
--nap; // decrement, because already incremented above, for new pointer element!
}else{
fprintf(stderr, "shmat returned %#8.8x\n", (unsigned int) pState->shm_addr);
}
break;
case 2:
// 2 - shmdt requested
/*
get the address, make the call, report the results and make the
internal state match
//*/
readstring(area_addr, ADDR_DIGITS, "enter detach shm_addr");
if(-1 == (area_id = shmdt(area_addr))){
perror("shmdt failed");
}else{
fprintf(stderr, "shmdt returned %d\n", area_id);
for(pState = attached_segments, area_id = nap; --area_id; ++pState){
if(0 != (pState->shm_addr = area_addr))
*pState = attached_segments[--nap];
}
}
break;
case 3:
if(nap == 0) break;
readstring(area_addr, ADDR_DIGITS, "enter address of an attached segment");
if(good_addr(area_addr))
fprintf(stderr, "string @ %#x is '%s'\n",(unsigned int) area_addr, area_addr);
break;
case 4:
if(nap == 0) break;
readstring(area_addr, ADDR_DIGITS, "enter address of an attached segment");
/*
set up SIGSEGV signal handler to trap attempts to write into a read-only
attached segment
//*/
savefunc = signal(SIGSEGV, signalhandler);
if(setjmp(segvbuf)){
fprintf(stderr, "SIGSEGV signal caught: write aborted\n");
fflush(stdin);
signal(SIGSEGV, savefunc);
}else{
if(good_addr(area_addr)){
fflush(stdin);
readstring(area_addr, AREA_DIGITS, "enter one line to e copied to the shared segment attached");
// TODO: check
if(NULL == strncpy(pState->shm_addr, (char*) -1, sizeof(char*))){
perror("strncpy to shared memory failed");
break;
}
}
}
break;
}
}
}
// not reached
puts("READY.");
exit(EXIT_SUCCESS);
}
static void
plan_b(const char *filename)
{
FILE *ifp;
size_t i = 0, j, len, maxlen = 1;
char *lbuf = NULL, *p;
bool found_revision = (revision == NULL);
using_plan_a = false;
if ((ifp = fopen(filename, "r")) == NULL)
pfatal("can't open file %s", filename);
unlink(TMPINNAME);
if ((tifd = open(TMPINNAME, O_EXCL | O_CREAT | O_WRONLY, 0666)) < 0)
pfatal("can't open file %s", TMPINNAME);
while ((p = fgetln(ifp, &len)) != NULL) {
if (p[len - 1] == '\n')
p[len - 1] = '\0';
else {
/* EOF without EOL, copy and add the NUL */
if ((lbuf = malloc(len + 1)) == NULL)
fatal("out of memory\n");
memcpy(lbuf, p, len);
lbuf[len] = '\0';
p = lbuf;
last_line_missing_eol = true;
len++;
}
if (revision != NULL && !found_revision && rev_in_string(p))
found_revision = true;
if (len > maxlen)
maxlen = len; /* find longest line */
}
free(lbuf);
if (ferror(ifp))
pfatal("can't read file %s", filename);
if (revision != NULL) {
if (!found_revision) {
if (force) {
if (verbose)
say("Warning: this file doesn't appear "
"to be the %s version--patching anyway.\n",
revision);
} else if (batch) {
fatal("this file doesn't appear to be the "
"%s version--aborting.\n",
revision);
} else {
ask("This file doesn't appear to be the %s "
"version--patch anyway? [n] ",
revision);
if (*buf != 'y')
fatal("aborted\n");
}
} else if (verbose)
say("Good. This file appears to be the %s version.\n",
revision);
}
fseek(ifp, 0L, SEEK_SET); /* rewind file */
tireclen = maxlen;
tibuflen = maxlen > BUFFERSIZE ? maxlen : BUFFERSIZE;
lines_per_buf = tibuflen / maxlen;
tibuf[0] = malloc(tibuflen + 1);
if (tibuf[0] == NULL)
fatal("out of memory\n");
tibuf[1] = malloc(tibuflen + 1);
if (tibuf[1] == NULL)
fatal("out of memory\n");
for (i = 1;; i++) {
p = tibuf[0] + maxlen * (i % lines_per_buf);
if (i % lines_per_buf == 0) /* new block */
if (write(tifd, tibuf[0], tibuflen) !=
(ssize_t) tibuflen)
pfatal("can't write temp file");
if (fgets(p, maxlen + 1, ifp) == NULL) {
input_lines = i - 1;
if (i % lines_per_buf != 0)
if (write(tifd, tibuf[0], tibuflen) !=
(ssize_t) tibuflen)
pfatal("can't write temp file");
break;
}
j = strlen(p);
/* These are '\n' terminated strings, so no need to add a NUL */
if (j == 0 || p[j - 1] != '\n')
p[j] = '\n';
}
fclose(ifp);
close(tifd);
if ((tifd = open(TMPINNAME, O_RDONLY)) < 0)
pfatal("can't reopen file %s", TMPINNAME);
}
int
readboot(int dosfs, struct bootblock *boot)
{
u_char block[DOSBOOTBLOCKSIZE];
u_char fsinfo[2 * DOSBOOTBLOCKSIZE];
u_char backup[DOSBOOTBLOCKSIZE];
int ret = FSOK;
int i;
if ((size_t)read(dosfs, block, sizeof block) != sizeof block) {
perr("could not read boot block");
return FSFATAL;
}
if (block[510] != 0x55 || block[511] != 0xaa) {
pfatal("Invalid signature in boot block: %02x%02x",
block[511], block[510]);
return FSFATAL;
}
memset(boot, 0, sizeof *boot);
boot->ValidFat = -1;
/* decode bios parameter block */
boot->bpbBytesPerSec = block[11] + (block[12] << 8);
boot->bpbSecPerClust = block[13];
boot->bpbResSectors = block[14] + (block[15] << 8);
boot->bpbFATs = block[16];
boot->bpbRootDirEnts = block[17] + (block[18] << 8);
boot->bpbSectors = block[19] + (block[20] << 8);
boot->bpbMedia = block[21];
boot->bpbFATsmall = block[22] + (block[23] << 8);
boot->SecPerTrack = block[24] + (block[25] << 8);
boot->bpbHeads = block[26] + (block[27] << 8);
boot->bpbHiddenSecs = block[28] + (block[29] << 8) +
(block[30] << 16) + (block[31] << 24);
boot->bpbHugeSectors = block[32] + (block[33] << 8) +
(block[34] << 16) + (block[35] << 24);
boot->FATsecs = boot->bpbFATsmall;
if (!boot->bpbRootDirEnts)
boot->flags |= FAT32;
if (boot->flags & FAT32) {
boot->FATsecs = block[36] + (block[37] << 8)
+ (block[38] << 16) + (block[39] << 24);
if (block[40] & 0x80)
boot->ValidFat = block[40] & 0x0f;
/* check version number: */
if (block[42] || block[43]) {
/* Correct? XXX */
pfatal("Unknown file system version: %x.%x",
block[43], block[42]);
return FSFATAL;
}
boot->bpbRootClust = block[44] + (block[45] << 8)
+ (block[46] << 16) + (block[47] << 24);
boot->bpbFSInfo = block[48] + (block[49] << 8);
boot->bpbBackup = block[50] + (block[51] << 8);
if (lseek(dosfs, boot->bpbFSInfo * boot->bpbBytesPerSec,
SEEK_SET) != boot->bpbFSInfo * boot->bpbBytesPerSec
|| read(dosfs, fsinfo, sizeof fsinfo) != sizeof fsinfo) {
perr("could not read fsinfo block");
return FSFATAL;
}
if (memcmp(fsinfo, "RRaA", 4)
|| memcmp(fsinfo + 0x1e4, "rrAa", 4)
|| fsinfo[0x1fc]
|| fsinfo[0x1fd]
|| fsinfo[0x1fe] != 0x55
|| fsinfo[0x1ff] != 0xaa
|| fsinfo[0x3fc]
|| fsinfo[0x3fd]
|| fsinfo[0x3fe] != 0x55
|| fsinfo[0x3ff] != 0xaa) {
pwarn("Invalid signature in fsinfo block\n");
if (ask(0, "Fix")) {
memcpy(fsinfo, "RRaA", 4);
memcpy(fsinfo + 0x1e4, "rrAa", 4);
fsinfo[0x1fc] = fsinfo[0x1fd] = 0;
fsinfo[0x1fe] = 0x55;
fsinfo[0x1ff] = 0xaa;
fsinfo[0x3fc] = fsinfo[0x3fd] = 0;
fsinfo[0x3fe] = 0x55;
fsinfo[0x3ff] = 0xaa;
if (lseek(dosfs, boot->bpbFSInfo *
boot->bpbBytesPerSec, SEEK_SET)
!= boot->bpbFSInfo * boot->bpbBytesPerSec
|| write(dosfs, fsinfo, sizeof fsinfo)
!= sizeof fsinfo) {
perr("Unable to write bpbFSInfo");
return FSFATAL;
}
ret = FSBOOTMOD;
} else
boot->bpbFSInfo = 0;
}
if (boot->bpbFSInfo) {
boot->FSFree = fsinfo[0x1e8] + (fsinfo[0x1e9] << 8)
+ (fsinfo[0x1ea] << 16)
+ (fsinfo[0x1eb] << 24);
boot->FSNext = fsinfo[0x1ec] + (fsinfo[0x1ed] << 8)
+ (fsinfo[0x1ee] << 16)
+ (fsinfo[0x1ef] << 24);
}
if (lseek(dosfs, boot->bpbBackup * boot->bpbBytesPerSec,
SEEK_SET)
!= boot->bpbBackup * boot->bpbBytesPerSec
|| read(dosfs, backup, sizeof backup) != sizeof backup) {
perr("could not read backup bootblock");
return FSFATAL;
}
backup[65] = block[65]; /* XXX */
if (memcmp(block + 11, backup + 11, 79)) {
/*
* XXX We require a reference that explains
* that these bytes need to match, or should
* drop the check. gdt@NetBSD has observed
* filesystems that work fine under Windows XP
* and NetBSD that do not match, so the
* requirement is suspect. For now, just
* print out useful information and continue.
*/
pfatal("backup (block %d) mismatch with primary bootblock:\n",
boot->bpbBackup);
for (i = 11; i < 11 + 90; i++) {
if (block[i] != backup[i])
pfatal("\ti=%d\tprimary 0x%02x\tbackup 0x%02x\n",
i, block[i], backup[i]);
}
}
/* Check backup bpbFSInfo? XXX */
}
boot->ClusterOffset = (boot->bpbRootDirEnts * 32 +
boot->bpbBytesPerSec - 1) / boot->bpbBytesPerSec +
boot->bpbResSectors + boot->bpbFATs * boot->FATsecs -
CLUST_FIRST * boot->bpbSecPerClust;
if (boot->bpbBytesPerSec % DOSBOOTBLOCKSIZE != 0) {
pfatal("Invalid sector size: %u", boot->bpbBytesPerSec);
return FSFATAL;
}
if (boot->bpbSecPerClust == 0) {
pfatal("Invalid cluster size: %u", boot->bpbSecPerClust);
return FSFATAL;
}
if (boot->bpbSectors) {
boot->bpbHugeSectors = 0;
boot->NumSectors = boot->bpbSectors;
} else
boot->NumSectors = boot->bpbHugeSectors;
boot->NumClusters = (boot->NumSectors - boot->ClusterOffset) /
boot->bpbSecPerClust;
if (boot->flags&FAT32)
boot->ClustMask = CLUST32_MASK;
else if (boot->NumClusters < (CLUST_RSRVD&CLUST12_MASK))
boot->ClustMask = CLUST12_MASK;
else if (boot->NumClusters < (CLUST_RSRVD&CLUST16_MASK))
boot->ClustMask = CLUST16_MASK;
else {
pfatal("Filesystem too big (%u clusters) for non-FAT32 partition",
boot->NumClusters);
return FSFATAL;
}
switch (boot->ClustMask) {
case CLUST32_MASK:
boot->NumFatEntries = (boot->FATsecs * boot->bpbBytesPerSec) / 4;
break;
case CLUST16_MASK:
boot->NumFatEntries = (boot->FATsecs * boot->bpbBytesPerSec) / 2;
break;
default:
boot->NumFatEntries = (boot->FATsecs * boot->bpbBytesPerSec * 2) / 3;
break;
}
if (boot->NumFatEntries < boot->NumClusters) {
pfatal("FAT size too small, %u entries won't fit into %u sectors\n",
boot->NumClusters, boot->FATsecs);
return FSFATAL;
}
boot->ClusterSize = boot->bpbBytesPerSec * boot->bpbSecPerClust;
boot->NumFiles = 1;
boot->NumFree = 0;
return ret;
}
void CLineEdit::sNew()
{
QString uiName="customer";
ParameterList params;
QMessageBox ask(this);
ask.setIcon(QMessageBox::Question);
QPushButton *pbutton = ask.addButton(tr("Prospect"), QMessageBox::YesRole);
QPushButton *cbutton = ask.addButton(tr("Customer"), QMessageBox::YesRole);
ask.setDefaultButton(cbutton);
ask.setWindowTitle(tr("Customer or Prospect?"));
if (_subtype == CRMAcctLineEdit::Prospect ||
(_subtype == CRMAcctLineEdit::CustAndProspect &&
!_x_privileges->check("MaintainCustomerMasters")))
{
params.append("mode", "new");
uiName="prospect";
}
if (_subtype == CRMAcctLineEdit::CustAndProspect &&
!_x_privileges->check("MaintainProspectMasters"))
params.append("mode", "new");
else
{
if (_subtype == CRMAcctLineEdit::Cust)
ask.setText(tr("<p>Would you like to create a new Customer or convert "
"an existing Prospect?"));
else
ask.setText(tr("<p>Would you like to create a new Customer or "
"a new Prospect?"));
ask.exec();
if (ask.clickedButton() == pbutton &&
_subtype == CRMAcctLineEdit::Cust) // converting prospect
{
int prospectid = -1;
if (_x_preferences->value("DefaultEllipsesAction") == "search")
{
CRMAcctSearch* search = new CRMAcctSearch(this);
search->setSubtype(CRMAcctLineEdit::Prospect);
prospectid = search->exec();
}
else
{
CRMAcctList* list = new CRMAcctList(this);
list->setSubtype(CRMAcctLineEdit::Prospect);
prospectid = list->exec();
}
if (prospectid > 0)
{
XSqlQuery convertq;
convertq.prepare("SELECT convertProspectToCustomer(:id) AS result;");
convertq.bindValue(":id", prospectid);
convertq.exec();
if (convertq.first())
{
int result = convertq.value("result").toInt();
if (result < 0)
{
QMessageBox::critical(this, tr("Processing Error"),
storedProcErrorLookup("convertProspectToCustomer", result));
return;
}
params.append("cust_id", prospectid);
params.append("mode", "edit");
}
}
else
return;
}
else
{
params.append("mode", "new");
if (ask.clickedButton() == pbutton)
uiName = "prospect";
}
}
sOpenWindow(uiName, params);
}
