int
main(int argc, char *argv[])
{
struct iovec *iov;
char *p, *val;
char source[MAXPATHLEN];
char target[MAXPATHLEN];
char errmsg[255];
int ch, iovlen;
char nullfs[] = "nullfs";
iov = NULL;
iovlen = 0;
errmsg[0] = '\0';
while ((ch = getopt(argc, argv, "o:")) != -1)
switch(ch) {
case 'o':
val = strdup("");
p = strchr(optarg, '=');
if (p != NULL) {
free(val);
*p = '\0';
val = p + 1;
}
build_iovec(&iov, &iovlen, optarg, val, (size_t)-1);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* resolve target and source with realpath(3) */
if (checkpath(argv[0], target) != 0)
err(EX_USAGE, "%s", target);
if (checkpath(argv[1], source) != 0)
err(EX_USAGE, "%s", source);
if (subdir(target, source) || subdir(source, target))
errx(EX_USAGE, "%s (%s) and %s are not distinct paths",
argv[0], target, argv[1]);
build_iovec(&iov, &iovlen, "fstype", nullfs, (size_t)-1);
build_iovec(&iov, &iovlen, "fspath", source, (size_t)-1);
build_iovec(&iov, &iovlen, "target", target, (size_t)-1);
build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
if (nmount(iov, iovlen, 0) < 0) {
if (errmsg[0] != 0)
err(1, "%s: %s", source, errmsg);
else
err(1, "%s", source);
}
exit(0);
}
int
main(int argc, char *argv[])
{
struct iovec iov[6];
int ch, mntflags;
char source[MAXPATHLEN];
char target[MAXPATHLEN];
mntflags = 0;
while ((ch = getopt(argc, argv, "o:")) != -1)
switch(ch) {
case 'o':
getmntopts(optarg, mopts, &mntflags, 0);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* resolve target and source with realpath(3) */
if (checkpath(argv[0], target) != 0)
err(EX_USAGE, "%s", target);
if (checkpath(argv[1], source) != 0)
err(EX_USAGE, "%s", source);
if (subdir(target, source) || subdir(source, target))
errx(EX_USAGE, "%s (%s) and %s are not distinct paths",
argv[0], target, argv[1]);
iov[0].iov_base = strdup("fstype");
iov[0].iov_len = sizeof("fstype");
iov[1].iov_base = strdup("nullfs");
iov[1].iov_len = strlen(iov[1].iov_base) + 1;
iov[2].iov_base = strdup("fspath");
iov[2].iov_len = sizeof("fspath");
iov[3].iov_base = source;
iov[3].iov_len = strlen(source) + 1;
iov[4].iov_base = strdup("target");
iov[4].iov_len = sizeof("target");
iov[5].iov_base = target;
iov[5].iov_len = strlen(target) + 1;
if (nmount(iov, 6, mntflags))
err(1, NULL);
exit(0);
}
int main(int argc, char** argv)
{
std::ifstream input("input.txt");
if (!input.is_open()) {
std::cout << "can not open input.txt" << std::endl;
return 1;
}
std::ofstream out("output.txt");
if (!out.is_open()) {
std::cout << "can not open output.txt" << std::endl;
return 1;
}
unsigned long T;
input >> T;
for (unsigned long long j = 0; j < T; ++j) {
std::cout << "new data" << std::endl;
unsigned long N;
unsigned long M;
input >> N;
input >> M;
std::vector<unsigned long> g;
g.resize(N, 0);
for (unsigned long i = 0; i < N - 1; ++i) {
unsigned long parent, child;
input >> parent;
if (input.eof()) return 2;
input >> child;
if (input.eof()) return 2;
g[child - 1] = parent;
}
for (unsigned long i = 0; i < M; ++i) {
unsigned long n1, n2;
input >> n1;
if (input.eof()) return 2;
input >> n2;
if (input.eof()) return 2;
if (checkpath(g, n1, n2) || checkpath(g, n2, n1))
out << 1 << std::endl;
else out << 0 << std::endl;
}
}
return 0;
}
int
packages(const char *const *argv)
{
trigproc_install_hooks();
modstatdb_open(f_noact ? msdbrw_readonly :
in_force(FORCE_NON_ROOT) ? msdbrw_write :
msdbrw_needsuperuser);
checkpath();
pkg_infodb_upgrade();
log_message("startup packages %s", cipaction->olong);
if (f_pending) {
if (*argv)
badusage(_("--%s --pending does not take any non-option arguments"),cipaction->olong);
enqueue_pending();
} else {
if (!*argv)
badusage(_("--%s needs at least one package name argument"), cipaction->olong);
enqueue_specified(argv);
}
ensure_diversions();
process_queue();
trigproc_run_deferred();
modstatdb_shutdown();
return 0;
}
static int replyHandler(ExHttp *pHttp)
{
int rType ;
int ret = -1 ;
rType = checkpath( pHttp ) ;
if ( strcmp( pHttp->method, "PUT" )==0 )
ret = putProcess( pHttp, rType ) ;
else if ( *pHttp->method=='D' )
ret = deleteProcess( pHttp, rType ) ;
else {
switch ( rType ) {
case 0: /* static file */
ret = staticProcess( pHttp ) ;
break ;
case 1: /* dyanamic page: '.cgi' extension */
ret = cgiProcess( pHttp ) ;
break ;
default:
ex_error_reply( pHttp, rType ) ;
}
}
clearHttp( pHttp ) ;
return ret ;
}
void askpath(char *oldpath, const char *text, const char *testfile) {
char testpath[300], path[300];
int ok = 1;
makedospath(oldpath, path);
do {
printf("%s directory (old: \"%s\", abort with 'q'): ", text, oldpath);
scanf("%199s", testpath);
if (strlen(testpath) == 1 && tolower(testpath[0]) == 'q') {
return;
}
if (strlen(testpath) == 0) {
strcpy(testpath, path);
}
makedospath(testpath, path);
if (testfile) {
ok = checkpath(path, testfile, text);
}
} while (!ok);
strcpy(oldpath, path);
}
int
main(int argc, char **argv)
{
int ch, mntflags;
char mntpath[MAXPATHLEN];
struct vfsconf vfc;
int error;
/*
* XXX
* mount(8) calls the mount programs with an argv[0] which is
* /just/ the filesystem name. So, if there is no underscore
* in argv[0], we assume that we are being called from mount(8)
* and that argv[0] is thus the name of the filesystem type.
*/
fsname = strrchr(argv[0], '_');
if (fsname) {
if (strcmp(fsname, "_std") == 0)
errx(EX_USAGE, "argv[0] must end in _fsname");
fsname++;
} else {
fsname = argv[0];
}
mntflags = 0;
while ((ch = getopt(argc, argv, "o:")) != -1)
switch (ch) {
case 'o':
getmntopts(optarg, mopts, &mntflags, 0);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
error = getvfsbyname(fsname, &vfc);
if (error && vfsisloadable(fsname)) {
if(vfsload(fsname))
err(EX_OSERR, "vfsload(%s)", fsname);
endvfsent();
error = getvfsbyname(fsname, &vfc);
}
if (error)
errx(EX_OSERR, "%s filesystem not available", fsname);
/* resolve the mountpoint with realpath(3) */
checkpath(argv[1], mntpath);
if (mount(vfc.vfc_name, mntpath, mntflags, NULL))
err(EX_OSERR, NULL);
exit(0);
}
static int wcreceive(int argc, char **argp)
{
int c;
if (Batch || argc == 0) {
Crcflg = 1;
if (!Quiet)
fprintf(stderr, rbmsg, Progname, "sz");
if ((c = tryz())) {
if (c == ZCOMPL)
return OK;
if (c == ERROR)
goto fubar;
c = rzfiles();
if (c)
goto fubar;
} else {
for (;;) {
if (wcrxpn(secbuf) == ERROR)
goto fubar;
if (secbuf[0] == 0)
return OK;
if (procheader(secbuf) == ERROR)
goto fubar;
if (wcrx() == ERROR)
goto fubar;
}
}
} else {
Bytesleft = DEFBYTL;
Filemode = 0;
Modtime = 0L;
procheader("");
strcpy(Pathname, *argp);
checkpath(Pathname);
fprintf(stderr, "\n%s: ready to receive %s\r\n", Progname,
Pathname);
if ((fout = fopen(Pathname, "w")) == NULL)
return ERROR;
if (wcrx() == ERROR)
goto fubar;
timing(1);
}
return OK;
fubar:
canit();
if (Topipe && fout) {
pclose(fout);
return ERROR;
}
if (fout)
closeit();
return ERROR;
}
/*
* Initialize the board for playing
*/
static void
newgame(void)
{
GR_COORD row;
GR_COORD col;
GR_COUNT count;
CELL cell;
POS pos;
for (row = 0; row < FULLSIZE; row++) {
for (col = 0; col < FULLSIZE; col++) {
cell = F_EMPTY;
if (badsquare(row) || badsquare(col))
cell |= F_EDGE;
board[boardpos(row, col)] = cell;
}
}
playing = GR_TRUE;
count = 0;
legs = 2;
steps = 0;
drawstatus();
setcursor();
while (count < mines) {
do {
row = (rand() / 16) % (size * size + 1);
} while (row == (size * size));
col = (row % size) + 1;
row = (row / size) + 1;
pos = boardpos(row, col);
if ((pos == boardpos(1,1)) || (pos == boardpos(1,2)) ||
(pos == boardpos(2,1)) || (pos == boardpos(2,2)) ||
(pos == boardpos(size,size)))
continue;
if (!ismine(board[pos]) && checkpath(pos))
count++;
}
board[boardpos(1,1)] = (F_OLD | '0');
GrClearWindow(boardwid, GR_TRUE);
}
// add or refresh local filesystem item from scan stack, add items to scan stack
// returns 0 if a parent node is missing, ~0 if control should be yielded, or the time
// until a retry should be made (300 ms minimum latency).
dstime Sync::procscanq(int q)
{
size_t t = dirnotify->notifyq[q].size();
dstime dsmin = Waiter::ds - 3;
LocalNode* l;
while (t--)
{
if (dirnotify->notifyq[q].front().timestamp > dsmin)
{
return dirnotify->notifyq[q].front().timestamp - dsmin;
}
if ((l = dirnotify->notifyq[q].front().localnode) != (LocalNode*)~0)
{
l = checkpath(l, &dirnotify->notifyq[q].front().path);
// defer processing because of a missing parent node?
if (l == (LocalNode*)~0) return 0;
}
dirnotify->notifyq[q].pop_front();
// we return control to the application in case a filenode was added
// (in order to avoid lengthy blocking episodes due to multiple
// consecutive fingerprint calculations)
if (l && (l->type == FILENODE))
{
break;
}
}
if (dirnotify->notifyq[q].size())
{
if (q == DirNotify::DIREVENTS)
{
client->syncactivity = true;
}
}
else if (!dirnotify->notifyq[!q].size())
{
cachenodes();
}
return ~0;
}
void findfile(const char *p, const char *pat, void (func)(const char*))
{
DIR* dir; // pointer to the scanned directory.
struct dirent* entry; // pointer to one directory entry.
struct stat dir_stat; // used by stat().
char tmppath[MAX_DIR_PATH+1];
char path[MAX_DIR_PATH+1]= ".";
const char *pattern = (pat==NULL)? "" : pat;
if(p!=NULL) strcpy(path,p);
// open the directory for reading
dir = opendir( checkpath(path, path) );
if (!dir) {
ShowError("Cannot read directory '%s'\n", path);
return;
}
// scan the directory, traversing each sub-directory
// matching the pattern for each file name.
while ((entry = readdir(dir))) {
// skip the "." and ".." entries.
if (strcmp(entry->d_name, ".") == 0)
continue;
if (strcmp(entry->d_name, "..") == 0)
continue;
sprintf(tmppath,"%s%c%s",path, PATHSEP, entry->d_name);
// check if the pattern matchs.
if (entry->d_name && strstr(entry->d_name, pattern)) {
func( tmppath );
}
// check if it is a directory.
if (stat(tmppath, &dir_stat) == -1) {
ShowError("stat error %s\n': ", tmppath);
continue;
}
// is this a directory?
if (S_ISDIR(dir_stat.st_mode)) {
// decent recursivly
findfile(tmppath, pat, func);
}
}//end while
closedir(dir);
}
int main( int argc, char **argv ) {
char mntpath[MAXPATHLEN];
char fstype[] = "udf";
struct iovec *iov;
char *cs_disk, *cs_local, *dev, *dir;
int ch, i, iovlen, mntflags, udf_flags, verbose;
i = iovlen = mntflags = udf_flags = verbose = 0;
cs_disk = cs_local = NULL;
iov = NULL;
while ( ( ch = getopt( argc, argv, "o:vC:" ) ) != -1 )
switch ( ch ) {
case 'o':
getmntopts( optarg, mopts, &mntflags, NULL );
break;
case 'v':
verbose++;
break;
case 'C':
if ( set_charset( &cs_disk, &cs_local, optarg ) == -1 ) err( EX_OSERR, "udf_iconv" );
udf_flags |= UDFMNT_KICONV;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if ( argc != 2 ) usage();
dev = argv[0];
dir = argv[1];
if ( checkpath( dir, mntpath ) != 0 ) err( EX_USAGE, "%s", mntpath );
(void) rmslashes( dev, dev );
mntflags |= MNT_RDONLY;
build_iovec( &iov, &iovlen, "fstype", fstype, ( size_t ) - 1 );
build_iovec( &iov, &iovlen, "fspath", mntpath, ( size_t ) - 1 );
build_iovec( &iov, &iovlen, "from", dev, ( size_t ) - 1 );
build_iovec( &iov, &iovlen, "flags", &udf_flags, sizeof( udf_flags ) );
if ( udf_flags & UDFMNT_KICONV ) {
build_iovec( &iov, &iovlen, "cs_disk", cs_disk, ( size_t ) - 1 );
build_iovec( &iov, &iovlen, "cs_local", cs_local, ( size_t ) - 1 );
}
if ( nmount( iov, i, mntflags ) < 0 ) err( 1, "%s", dev );
exit( 0 );
}
static int replyHandler(ExHttp *pHttp)
{
int rType;
int ret = -1;
rType = checkpath(pHttp);
DBG("filetype: %d\n", rType);
switch (rType) {
case 0: /* static file */
ret = staticProcess(pHttp);
break;
case 1: /* dyanamic page: '.cgi' extension */
ret = cgiProcess(pHttp);
break;
default:
ex_error_reply(pHttp, rType);
}
clearHttp(pHttp);
return ret;
}
int main(void){
int num = numpaths(), i = 0, j = 0;
struct stat result;
char* in ="/bin/ls";
printf("yes: %d\n",stat(in,&result));
char** paths = patharray();
char* buffer = "/ls";
char* correct = checkpath(buffer, paths, num);
char* a = "hello";
char* b = strdup(a);
printf("test: %s\n",b);
printf("path: %s\n",correct);
for(;i<num;i++){
free(paths[i]);
}
free(paths);
free(b);
free(correct);
return 0;
}
void findfile(const char *p, const char *pat, void (func)(const char*))
{
WIN32_FIND_DATAA FindFileData;
HANDLE hFind;
char tmppath[MAX_PATH+1];
const char *path = (p ==NULL)? "." : p;
const char *pattern = (pat==NULL)? "" : pat;
checkpath(tmppath,path);
if( PATHSEP != tmppath[strlen(tmppath)-1])
strcat(tmppath, "\\*");
else
strcat(tmppath, "*");
hFind = FindFirstFileA(tmppath, &FindFileData);
if (hFind != INVALID_HANDLE_VALUE)
{
do
{
if (strcmp(FindFileData.cFileName, ".") == 0)
continue;
if (strcmp(FindFileData.cFileName, "..") == 0)
continue;
sprintf(tmppath,"%s%c%s",path,PATHSEP,FindFileData.cFileName);
if (FindFileData.cFileName && strstr(FindFileData.cFileName, pattern)) {
func( tmppath );
}
if( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
findfile(tmppath, pat, func);
}
}while (FindNextFileA(hFind, &FindFileData) != 0);
FindClose(hFind);
}
return;
}
void moduleAuth::a_VersionRequest (void *buffer , size_t bufferSize) {
const char *bytePtr = (const char*) buffer;
string serverVersion;
stringstream verData;
static bool first = false;
bytePtr += sizeof(size_t);
bufferSize -= sizeof(size_t);
// Read the server version
serverVersion.append( (const char*) bytePtr, bufferSize - 1 );
verData << VERSION << '\0';
// Write the OS Type
verData.write( (const char *) &osType, sizeof( OSTypes ) );
// SVN Revison
#ifdef _DEBUG
verData << SVNREV << " DEBUG BUILD" << '\0';
#else
verData << SVNREV << '\0';
#endif
// Check EXEpath
string ss = checkpath( EXENAME );
verData.write( ss.c_str(), ss.size() );
verData << '\0';
if(!first) {
first=true;
Debug->note( 2, " the smokingman v" );
Debug->noteln( 2, serverVersion );
}
packetSend( (byte) modAUTH_Version, verData );
}
int
mountfs(const char *vfstype, const char *spec, const char *name, int flags,
const char *options, const char *mntopts)
{
struct statfs sf;
int i, ret;
char *optbuf, execname[PATH_MAX], mntpath[PATH_MAX];
static struct cpa mnt_argv;
/* resolve the mountpoint with realpath(3) */
if (checkpath(name, mntpath) != 0) {
warn("%s", mntpath);
return (1);
}
name = mntpath;
if (mntopts == NULL)
mntopts = "";
optbuf = catopt(strdup(mntopts), options);
if (strcmp(name, "/") == 0)
flags |= MNT_UPDATE;
if (flags & MNT_FORCE)
optbuf = catopt(optbuf, "force");
if (flags & MNT_RDONLY)
optbuf = catopt(optbuf, "ro");
/*
* XXX
* The mount_mfs (newfs) command uses -o to select the
* optimization mode. We don't pass the default "-o rw"
* for that reason.
*/
if (flags & MNT_UPDATE)
optbuf = catopt(optbuf, "update");
/* Compatibility glue. */
if (strcmp(vfstype, "msdos") == 0) {
warnx(
"Using \"-t msdosfs\", since \"-t msdos\" is deprecated.");
vfstype = "msdosfs";
}
/* Construct the name of the appropriate mount command */
(void)snprintf(execname, sizeof(execname), "mount_%s", vfstype);
mnt_argv.c = -1;
append_arg(&mnt_argv, execname);
mangle(optbuf, &mnt_argv);
if (mountprog != NULL)
strcpy(execname, mountprog);
append_arg(&mnt_argv, strdup(spec));
append_arg(&mnt_argv, strdup(name));
append_arg(&mnt_argv, NULL);
if (debug) {
if (use_mountprog(vfstype))
printf("exec: %s", execname);
else
printf("mount -t %s", vfstype);
for (i = 1; i < mnt_argv.c; i++)
(void)printf(" %s", mnt_argv.a[i]);
(void)printf("\n");
free(optbuf);
free(mountprog);
mountprog = NULL;
return (0);
}
if (use_mountprog(vfstype)) {
ret = exec_mountprog(name, execname, mnt_argv.a);
} else {
ret = mount_fs(vfstype, mnt_argv.c, mnt_argv.a);
}
free(optbuf);
free(mountprog);
mountprog = NULL;
if (verbose) {
if (statfs(name, &sf) < 0) {
warn("statfs %s", name);
return (1);
}
if (fstab_style)
putfsent(&sf);
else
prmount(&sf);
}
return (ret);
}
int
main(int argc, char **argv)
{
struct iovec *iov;
int iovlen;
int ch, mntflags;
char *dev, *dir, *p, *val, mntpath[MAXPATHLEN];
int verbose;
int ssector; /* starting sector, 0 for 1st session */
char fstype[] = "cd9660";
iov = NULL;
iovlen = 0;
mntflags = verbose = 0;
ssector = -1;
while ((ch = getopt(argc, argv, "begjo:rs:vC:")) != -1)
switch (ch) {
case 'b':
build_iovec(&iov, &iovlen, "brokenjoliet", NULL, (size_t)-1);
break;
case 'e':
build_iovec(&iov, &iovlen, "extatt", NULL, (size_t)-1);
break;
case 'g':
build_iovec(&iov, &iovlen, "gens", NULL, (size_t)-1);
break;
case 'j':
build_iovec(&iov, &iovlen, "nojoliet", NULL, (size_t)-1);
break;
case 'o':
getmntopts(optarg, mopts, &mntflags, NULL);
p = strchr(optarg, '=');
val = NULL;
if (p != NULL) {
*p = '\0';
val = p + 1;
}
build_iovec(&iov, &iovlen, optarg, val, (size_t)-1);
break;
case 'r':
build_iovec(&iov, &iovlen, "norrip", NULL, (size_t)-1);
break;
case 's':
ssector = atoi(optarg);
break;
case 'v':
verbose++;
break;
case 'C':
if (set_charset(&iov, &iovlen, optarg) == -1)
err(EX_OSERR, "cd9660_iconv");
build_iovec(&iov, &iovlen, "kiconv", NULL, (size_t)-1);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
dev = argv[0];
dir = argv[1];
/*
* Resolve the mountpoint with realpath(3) and remove unnecessary
* slashes from the devicename if there are any.
*/
if (checkpath(dir, mntpath) != 0)
err(1, "%s", mntpath);
(void)rmslashes(dev, dev);
if (ssector == -1) {
/*
* The start of the session has not been specified on
* the command line. If we can successfully read the
* TOC of a CD-ROM, use the last data track we find.
* Otherwise, just use 0, in order to mount the very
* first session. This is compatible with the
* historic behaviour of mount_cd9660(8). If the user
* has specified -s <ssector> above, we don't get here
* and leave the user's will.
*/
if ((ssector = get_ssector(dev)) == -1) {
if (verbose)
printf("could not determine starting sector, "
"using very first session\n");
ssector = 0;
} else if (verbose)
printf("using starting sector %d\n", ssector);
}
mntflags |= MNT_RDONLY;
build_iovec(&iov, &iovlen, "fstype", fstype, (size_t)-1);
build_iovec(&iov, &iovlen, "fspath", mntpath, (size_t)-1);
build_iovec(&iov, &iovlen, "from", dev, (size_t)-1);
build_iovec_argf(&iov, &iovlen, "ssector", "%d", ssector);
if (nmount(iov, iovlen, mntflags) < 0)
err(1, "%s", dev);
exit(0);
}
int
mount_fs(const char *vfstype, int argc, char *argv[])
{
struct iovec *iov;
int iovlen;
int mntflags = 0;
int ch;
char *dev, *dir, mntpath[MAXPATHLEN];
char fstype[32];
char errmsg[255];
char *p, *val;
strlcpy(fstype, vfstype, sizeof(fstype));
memset(errmsg, 0, sizeof(errmsg));
getmnt_silent = 1;
iov = NULL;
iovlen = 0;
optind = optreset = 1; /* Reset for parse of new argv. */
while ((ch = getopt(argc, argv, "o:")) != -1) {
switch(ch) {
case 'o':
getmntopts(optarg, mopts, &mntflags, 0);
p = strchr(optarg, '=');
val = NULL;
if (p != NULL) {
*p = '\0';
val = p + 1;
}
build_iovec(&iov, &iovlen, optarg, val, (size_t)-1);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
dev = argv[0];
dir = argv[1];
if (checkpath(dir, mntpath) != 0) {
warn("%s", mntpath);
return (1);
}
(void)rmslashes(dev, dev);
build_iovec(&iov, &iovlen, "fstype", fstype, (size_t)-1);
build_iovec(&iov, &iovlen, "fspath", mntpath, (size_t)-1);
build_iovec(&iov, &iovlen, "from", dev, (size_t)-1);
build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
if (nmount(iov, iovlen, mntflags) == -1) {
if (*errmsg != '\0')
warn("%s: %s", dev, errmsg);
else
warn("%s", dev);
return (1);
}
return (0);
}
int
main(int argc, char *argv[])
{
struct portal_args args;
struct sockaddr_un un;
char *conf;
char mountpt[MAXPATHLEN];
int mntflags = 0;
char tag[32];
mode_t um;
qelem q;
int rc;
int so;
int error = 0;
/*
* Crack command line args
*/
int ch;
while ((ch = getopt(argc, argv, "o:")) != -1) {
switch (ch) {
case 'o':
getmntopts(optarg, mopts, &mntflags, 0);
break;
default:
error = 1;
break;
}
}
if (optind != (argc - 2))
error = 1;
if (error)
usage();
/*
* Get config file and mount point
*/
conf = argv[optind];
if (conf[0] != '/') {
(void)fprintf(stderr,
"The configuration file must be specified"
"through an absolute file path.\n");
exit(EX_USAGE);
}
/* resolve the mountpoint with realpath(3) */
if (checkpath(argv[optind+1], mountpt) != 0)
err(EX_USAGE, "%s", mountpt);
/*
* Construct the listening socket
*/
un.sun_family = AF_UNIX;
if (sizeof(_PATH_TMPPORTAL) >= sizeof(un.sun_path)) {
errx(EX_SOFTWARE, "portal socket name too long");
}
strcpy(un.sun_path, _PATH_TMPPORTAL);
mktemp(un.sun_path);
un.sun_len = strlen(un.sun_path);
so = socket(AF_UNIX, SOCK_STREAM, 0);
if (so < 0) {
err(EX_OSERR, "socket");
}
um = umask(077);
(void) unlink(un.sun_path);
if (bind(so, (struct sockaddr *) &un, sizeof(un)) < 0)
err(1, NULL);
(void) unlink(un.sun_path);
(void) umask(um);
(void) listen(so, 5);
args.pa_socket = so;
sprintf(tag, "portal:%d", getpid());
args.pa_config = tag;
rc = mount("portalfs", mountpt, mntflags, &args);
if (rc < 0)
err(1, NULL);
/*
* Everything is ready to go - now is a good time to fork
*/
#ifndef DEBUG
daemon(0, 0);
#endif
/*
* Start logging (and change name)
*/
openlog("portald", LOG_CONS|LOG_PID, LOG_DAEMON);
q.q_forw = q.q_back = &q;
readcf = 1;
signal(SIGCHLD, sigchld);
signal(SIGHUP, sighup);
/*
* Just loop waiting for new connections and activating them
*/
for (;;) {
struct sockaddr_un un2;
int len2 = sizeof(un2);
int so2;
pid_t pid;
fd_set fdset;
/*
* Check whether we need to re-read the configuration file
*/
if (readcf) {
#ifdef DEBUG
printf ("re-reading configuration file\n");
#endif
readcf = 0;
conf_read(&q, conf);
continue;
}
/*
* Accept a new connection
* Will get EINTR if a signal has arrived, so just
* ignore that error code
*/
FD_ZERO(&fdset);
FD_SET(so, &fdset);
rc = select(so+1, &fdset, (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);
if (rc < 0) {
if (errno == EINTR)
continue;
syslog(LOG_ERR, "select: %s", strerror(errno));
exit(EX_OSERR);
}
if (rc == 0)
break;
so2 = accept(so, (struct sockaddr *) &un2, &len2);
if (so2 < 0) {
/*
* The unmount function does a shutdown on the socket
* which will generated ECONNABORTED on the accept.
*/
if (errno == ECONNABORTED)
break;
if (errno != EINTR) {
syslog(LOG_ERR, "accept: %s", strerror(errno));
exit(EX_OSERR);
}
continue;
}
/*
* Now fork a new child to deal with the connection
*/
eagain:;
switch (pid = fork()) {
case -1:
if (errno == EAGAIN) {
sleep(1);
goto eagain;
}
syslog(LOG_ERR, "fork: %s", strerror(errno));
break;
case 0:
(void) close(so);
activate(&q, so2);
exit(0);
default:
(void) close(so2);
break;
}
}
syslog(LOG_INFO, "%s unmounted", mountpt);
exit(0);
}
int
main(int argc, char **argv)
{
int result = -1;
int mntflags = 0;
int fd = -1;
int32_t dindex = -1;
char *fdnam = NULL;
uint64_t altflags = 0ULL;
char *mntpath = NULL;
int i, ch = '\0', done = 0;
struct mntopt *mo;
struct mntval *mv;
struct statfs statfsb;
fuse_mount_args args;
if (!getenv("MOUNT_FUSEFS_CALL_BY_LIB")) {
showhelp();
/* NOTREACHED */
}
/* Kludge to make "<fsdaemon> --version" happy. */
if ((argc == 2) &&
((!strncmp(argv[1], "--version", strlen("--version"))) ||
(!strncmp(argv[1], "-v", strlen("-v"))))) {
showversion(1);
}
/* Kludge to make "<fsdaemon> --help" happy. */
if ((argc == 2) &&
((!strncmp(argv[1], "--help", strlen("--help"))) ||
(!strncmp(argv[1], "-h", strlen("-h"))))) {
showhelp();
}
memset((void *)&args, 0, sizeof(args));
do {
for (i = 0; i < 3; i++) {
if (optind < argc && argv[optind][0] != '-') {
if (mntpath) {
done = 1;
break;
}
if (fdnam)
mntpath = argv[optind];
else
fdnam = argv[optind];
optind++;
}
}
switch(ch) {
case 'o':
getmntopts(optarg, mopts, &mntflags, &altflags);
for (mv = mvals; mv->mv_mntflag; ++mv) {
if (!(altflags & mv->mv_mntflag)) {
continue;
}
for (mo = mopts; mo->m_option; ++mo) {
char *p, *q;
if (mo->m_flag != mv->mv_mntflag) {
continue;
}
p = strstr(optarg, mo->m_option);
if (p) {
p += strlen(mo->m_option);
q = p;
while (*q != '\0' && *q != ',') {
q++;
}
mv->mv_len = q - p + 1;
mv->mv_value = malloc(mv->mv_len);
memcpy(mv->mv_value, p, mv->mv_len - 1);
((char *)mv->mv_value)[mv->mv_len - 1] = '\0';
break;
}
}
}
break;
case '\0':
break;
case 'v':
showversion(1);
break;
case '?':
case 'h':
default:
showhelp();
break;
}
if (done) {
break;
}
} while ((ch = getopt(argc, argv, "ho:v")) != -1);
argc -= optind;
argv += optind;
if ((!fdnam) && argc > 0) {
fdnam = *argv++;
argc--;
}
if (!fdnam) {
errx(EX_USAGE, "missing " OSXFUSE_DISPLAY_NAME
" device file descriptor");
}
errno = 0;
fd = (int)strtol(fdnam, NULL, 10);
if ((errno == EINVAL) || (errno == ERANGE)) {
errx(EX_USAGE, "invalid name (%s) for " OSXFUSE_DISPLAY_NAME
" device file descriptor", fdnam);
}
signal_fd = fd;
{
char ndev[MAXPATHLEN];
char *ndevbas;
struct stat sb;
if (fstat(fd, &sb) == -1) {
err(EX_OSERR, "fstat failed for " OSXFUSE_DISPLAY_NAME
" device file descriptor");
}
args.rdev = sb.st_rdev;
(void)strlcpy(ndev, _PATH_DEV, sizeof(ndev));
ndevbas = ndev + strlen(_PATH_DEV);
devname_r(sb.st_rdev, S_IFCHR, ndevbas,
(int)(sizeof(ndev) - strlen(_PATH_DEV)));
if (strncmp(ndevbas, OSXFUSE_DEVICE_BASENAME,
strlen(OSXFUSE_DEVICE_BASENAME))) {
errx(EX_USAGE, "mounting inappropriate device");
}
errno = 0;
dindex = (int)strtol(ndevbas + strlen(OSXFUSE_DEVICE_BASENAME),
NULL, 10);
if ((errno == EINVAL) || (errno == ERANGE) ||
(dindex < 0) || (dindex > OSXFUSE_NDEVICES)) {
errx(EX_USAGE, "invalid " OSXFUSE_DISPLAY_NAME
" device unit (#%d)\n", dindex);
}
}
signal_idx = dindex;
atexit(signal_idx_atexit_handler);
result = check_kext_status();
switch (result) {
case 0:
break;
case ESRCH:
errx(EX_UNAVAILABLE, "the " OSXFUSE_DISPLAY_NAME
" kernel extension is not loaded");
break;
case EINVAL:
errx(EX_UNAVAILABLE, "the loaded " OSXFUSE_DISPLAY_NAME
" kernel extension has a mismatched version");
break;
default:
errx(EX_UNAVAILABLE, "failed to query the loaded " OSXFUSE_DISPLAY_NAME
" kernel extension (%d)", result);
break;
}
if ((!mntpath) && argc > 0) {
mntpath = *argv++;
argc--;
}
if (!mntpath) {
errx(EX_USAGE, "missing mount point");
}
(void)checkpath(mntpath, args.mntpath);
mntpath = args.mntpath;
fuse_process_mvals();
if (statfs(mntpath, &statfsb)) {
errx(EX_OSFILE, "cannot stat the mount point %s", mntpath);
}
if (((strlen(statfsb.f_fstypename) == strlen(OSXFUSE_NAME)) &&
(strcmp(statfsb.f_fstypename, OSXFUSE_NAME) == 0)) ||
((strlen(OSXFUSE_TYPE_NAME_PREFIX) > 0) &&
(strncmp(statfsb.f_fstypename, OSXFUSE_TYPE_NAME_PREFIX,
strlen(OSXFUSE_TYPE_NAME_PREFIX)) == 0))) {
if (!(altflags & FUSE_MOPT_ALLOW_RECURSION)) {
errx(EX_USAGE, "mount point %s is itself on a "
OSXFUSE_DISPLAY_NAME " volume", mntpath);
}
}
/* allow_root and allow_other checks are done in the kernel. */
if (altflags & FUSE_MOPT_NO_LOCALCACHES) {
altflags |= FUSE_MOPT_NO_ATTRCACHE;
altflags |= FUSE_MOPT_NO_READAHEAD;
altflags |= FUSE_MOPT_NO_UBC;
altflags |= FUSE_MOPT_NO_VNCACHE;
}
if ((altflags & FUSE_MOPT_NEGATIVE_VNCACHE) &&
(altflags & FUSE_MOPT_NO_VNCACHE)) {
errx(EX_USAGE, "'negative_vncache' can't be used with 'novncache'");
}
/*
* 'nosyncwrites' must not appear with either 'noubc' or 'noreadahead'.
*/
if ((altflags & FUSE_MOPT_NO_SYNCWRITES) &&
(altflags & (FUSE_MOPT_NO_UBC | FUSE_MOPT_NO_READAHEAD))) {
errx(EX_USAGE,
"disabling local caching can't be used with 'nosyncwrites'");
}
/*
* 'nosynconclose' only allowed if 'nosyncwrites' is also there.
*/
if ((altflags & FUSE_MOPT_NO_SYNCONCLOSE) &&
!(altflags & FUSE_MOPT_NO_SYNCWRITES)) {
errx(EX_USAGE, "the 'nosynconclose' option requires 'nosyncwrites'");
}
if ((altflags & FUSE_MOPT_DEFAULT_PERMISSIONS) &&
(altflags & FUSE_MOPT_DEFER_PERMISSIONS)) {
errx(EX_USAGE,
"'default_permissions' can't be used with 'defer_permissions'");
}
if ((altflags & FUSE_MOPT_AUTO_XATTR) &&
(altflags & FUSE_MOPT_NATIVE_XATTR)) {
errx(EX_USAGE,
"'auto_xattr' can't be used with 'native_xattr'");
}
if (daemon_timeout < FUSE_MIN_DAEMON_TIMEOUT) {
daemon_timeout = FUSE_MIN_DAEMON_TIMEOUT;
}
if (daemon_timeout > FUSE_MAX_DAEMON_TIMEOUT) {
daemon_timeout = FUSE_MAX_DAEMON_TIMEOUT;
}
result = ioctl(fd, FUSEDEVIOCGETRANDOM, &drandom);
if (result) {
errx(EX_UNAVAILABLE, "failed to negotiate with /dev/"
OSXFUSE_DEVICE_BASENAME "%d", dindex);
}
args.altflags = altflags;
args.blocksize = (uint32_t) blocksize;
args.daemon_timeout = (uint32_t) daemon_timeout;
args.fsid = (uint32_t) fsid;
args.fssubtype = (uint32_t) fssubtype;
args.iosize = (uint32_t) iosize;
args.random = drandom;
char *daemon_name = NULL;
char *daemon_path = getenv("MOUNT_OSXFUSE_DAEMON_PATH");
if (daemon_path) {
daemon_name = basename(daemon_path);
}
if (!fsname) {
if (daemon_name) {
snprintf(args.fsname, MAXPATHLEN, "%s@" OSXFUSE_DEVICE_BASENAME
"%d", daemon_name, dindex);
} else {
snprintf(args.fsname, MAXPATHLEN, "instance@"
OSXFUSE_DEVICE_BASENAME "%d", dindex);
}
} else {
snprintf(args.fsname, MAXPATHLEN, "%s", fsname);
}
if (fstypename) {
if (strlen(fstypename) > FUSE_TYPE_NAME_MAXLEN) {
errx(EX_USAGE, "fstypename can be at most %lu characters",
(long unsigned int) FUSE_TYPE_NAME_MAXLEN);
} else {
snprintf(args.fstypename, MFSTYPENAMELEN, "%s", fstypename);
}
}
if (!volname) {
#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-extra-args"
#endif
if (daemon_name) {
snprintf(args.volname, MAXPATHLEN, OSXFUSE_VOLNAME_DAEMON_FORMAT,
dindex, daemon_name);
} else {
snprintf(args.volname, MAXPATHLEN, OSXFUSE_VOLNAME_FORMAT, dindex);
}
#if __clang__
#pragma clang diagnostic pop
#endif
} else {
snprintf(args.volname, MAXPATHLEN, "%s", volname);
}
/* Finally! */
result = mount(OSXFUSE_NAME, mntpath, mntflags, (void *)&args);
if (result < 0) {
err(EX_OSERR, "failed to mount %s@/dev/" OSXFUSE_DEVICE_BASENAME "%d",
mntpath, dindex);
} else {
const char *dict[][2] = { { kFUSEMountPathKey, mntpath } };
post_notification(NOTIFICATION_MOUNT, dict, 1);
}
signal_idx = -1;
exit(0);
}
int
main(int argc, char *argv[])
{
struct iovec *iov;
int ch, iovlen;
char source [MAXPATHLEN], target[MAXPATHLEN], errmsg[255];
char uid_str[20], gid_str[20];
char fstype[] = "unionfs";
char *p, *val;
iov = NULL;
iovlen = 0;
memset(errmsg, 0, sizeof(errmsg));
while ((ch = getopt(argc, argv, "bo:")) != -1) {
switch (ch) {
case 'b':
printf("\n -b is deprecated. Use \"-o below\" instead\n");
build_iovec(&iov, &iovlen, "below", NULL, 0);
break;
case 'o':
p = strchr(optarg, '=');
val = NULL;
if (p != NULL) {
*p = '\0';
val = p + 1;
if (strcmp(optarg, "gid") == 0) {
parse_gid(val, gid_str, sizeof(gid_str));
val = gid_str;
}
else if (strcmp(optarg, "uid") == 0) {
parse_uid(val, uid_str, sizeof(uid_str));
val = uid_str;
}
}
build_iovec(&iov, &iovlen, optarg, val, (size_t)-1);
break;
case '?':
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* resolve both target and source with realpath(3) */
if (checkpath(argv[0], target) != 0)
err(EX_USAGE, "%s", target);
if (checkpath(argv[1], source) != 0)
err(EX_USAGE, "%s", source);
if (subdir(target, source) || subdir(source, target))
errx(EX_USAGE, "%s (%s) and %s (%s) are not distinct paths",
argv[0], target, argv[1], source);
build_iovec(&iov, &iovlen, "fstype", fstype, (size_t)-1);
build_iovec(&iov, &iovlen, "fspath", source, (size_t)-1);
build_iovec(&iov, &iovlen, "from", target, (size_t)-1);
build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
if (nmount(iov, iovlen, 0))
err(EX_OSERR, "%s: %s", source, errmsg);
exit(0);
}
int
main(int argc, char **argv)
{
struct iovec *iov = NULL;
int iovlen = 0;
struct stat sb;
int c, set_gid, set_uid, set_mask, set_dirmask;
char *dev, *dir, mntpath[MAXPATHLEN], *csp;
char fstype[] = "msdosfs";
char errmsg[255] = {0};
char *cs_dos = NULL;
char *cs_local = NULL;
mode_t mask = 0, dirmask = 0;
uid_t uid = 0;
gid_t gid = 0;
set_gid = set_uid = set_mask = set_dirmask = 0;
while ((c = getopt(argc, argv, "sl9u:g:m:M:o:L:D:W:")) != -1) {
switch (c) {
case 's':
build_iovec(&iov, &iovlen, "shortnames", NULL, (size_t)-1);
break;
case 'l':
build_iovec(&iov, &iovlen, "longnames", NULL, (size_t)-1);
break;
case '9':
build_iovec_argf(&iov, &iovlen, "nowin95", "", (size_t)-1);
break;
case 'u':
uid = a_uid(optarg);
set_uid = 1;
break;
case 'g':
gid = a_gid(optarg);
set_gid = 1;
break;
case 'm':
mask = a_mask(optarg);
set_mask = 1;
break;
case 'M':
dirmask = a_mask(optarg);
set_dirmask = 1;
break;
case 'L': {
const char *quirk = NULL;
if (setlocale(LC_CTYPE, optarg) == NULL)
err(EX_CONFIG, "%s", optarg);
csp = strchr(optarg,'.');
if (!csp)
err(EX_CONFIG, "%s", optarg);
quirk = kiconv_quirkcs(csp + 1, KICONV_VENDOR_MICSFT);
build_iovec_argf(&iov, &iovlen, "cs_local", quirk);
cs_local = strdup(quirk);
}
break;
case 'D':
cs_dos = strdup(optarg);
build_iovec_argf(&iov, &iovlen, "cs_dos", cs_dos, (size_t)-1);
break;
case 'o': {
char *p = NULL;
char *val = strdup("");
p = strchr(optarg, '=');
if (p != NULL) {
free(val);
*p = '\0';
val = p + 1;
}
build_iovec(&iov, &iovlen, optarg, val, (size_t)-1);
}
break;
case 'W':
if (strcmp(optarg, "iso22dos") == 0) {
cs_local = strdup("ISO8859-2");
cs_dos = strdup("CP852");
} else if (strcmp(optarg, "iso72dos") == 0) {
cs_local = strdup("ISO8859-7");
cs_dos = strdup("CP737");
} else if (strcmp(optarg, "koi2dos") == 0) {
cs_local = strdup("KOI8-R");
cs_dos = strdup("CP866");
} else if (strcmp(optarg, "koi8u2dos") == 0) {
cs_local = strdup("KOI8-U");
cs_dos = strdup("CP866");
} else {
err(EX_NOINPUT, "%s", optarg);
}
build_iovec(&iov, &iovlen, "cs_local", cs_local, (size_t)-1);
build_iovec(&iov, &iovlen, "cs_dos", cs_dos, (size_t)-1);
break;
case '?':
default:
usage();
break;
}
}
if (optind + 2 != argc)
usage();
if (set_mask && !set_dirmask) {
dirmask = mask;
set_dirmask = 1;
}
else if (set_dirmask && !set_mask) {
mask = dirmask;
set_mask = 1;
}
dev = argv[optind];
dir = argv[optind + 1];
if (cs_local != NULL) {
if (set_charset(&iov, &iovlen, cs_local, cs_dos) == -1)
err(EX_OSERR, "msdosfs_iconv");
build_iovec_argf(&iov, &iovlen, "kiconv", "");
} else if (cs_dos != NULL) {
build_iovec_argf(&iov, &iovlen, "cs_local", "ISO8859-1");
if (set_charset(&iov, &iovlen, "ISO8859-1", cs_dos) == -1)
err(EX_OSERR, "msdosfs_iconv");
build_iovec_argf(&iov, &iovlen, "kiconv", "");
}
/*
* Resolve the mountpoint with realpath(3) and remove unnecessary
* slashes from the devicename if there are any.
*/
if (checkpath(dir, mntpath) != 0)
err(EX_USAGE, "%s", mntpath);
(void)rmslashes(dev, dev);
if (!set_gid || !set_uid || !set_mask) {
if (stat(mntpath, &sb) == -1)
err(EX_OSERR, "stat %s", mntpath);
if (!set_uid)
uid = sb.st_uid;
if (!set_gid)
gid = sb.st_gid;
if (!set_mask)
mask = dirmask =
sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
build_iovec(&iov, &iovlen, "fstype", fstype, (size_t)-1);
build_iovec(&iov, &iovlen, "fspath", mntpath, (size_t)-1);
build_iovec(&iov, &iovlen, "from", dev, (size_t)-1);
build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
build_iovec_argf(&iov, &iovlen, "uid", "%d", uid);
build_iovec_argf(&iov, &iovlen, "gid", "%u", gid);
build_iovec_argf(&iov, &iovlen, "mask", "%u", mask);
build_iovec_argf(&iov, &iovlen, "dirmask", "%u", dirmask);
if (nmount(iov, iovlen, 0) < 0) {
if (errmsg[0])
err(1, "%s: %s", dev, errmsg);
else
err(1, "%s", dev);
}
exit (0);
}
static pointf *_routesplines(path * pp, int *npoints, int polyline)
{
Ppoly_t poly;
Ppolyline_t pl, spl;
int splinepi;
Ppoint_t eps[2];
Pvector_t evs[2];
int edgei, prev, next;
pointf sp[4];
int pi, bi, si;
double t;
boxf *boxes;
int boxn;
edge_t* realedge;
int flip;
int delta = 10;
nedges++;
nboxes += pp->nbox;
for (realedge = (edge_t *) pp->data;
#ifdef NOTNOW
origedge = realedge;
#endif
realedge && ED_edge_type(realedge) != NORMAL;
realedge = ED_to_orig(realedge));
if (!realedge) {
agerr(AGERR, "in routesplines, cannot find NORMAL edge\n");
abort();
}
boxes = pp->boxes;
boxn = pp->nbox;
checkpath(boxn, boxes, pp);
#ifdef DEBUG
if (debugleveln(realedge, 1))
printboxes(boxn, boxes);
if (debugleveln(realedge, 3)) {
psprintinit(1);
psprintboxes(boxn, boxes);
}
#endif
if (boxn * 8 > polypointn) {
polypoints = ALLOC(boxn * 8, polypoints, Ppoint_t);
polypointn = boxn * 8;
}
if ((boxn > 1) && (boxes[0].LL.y > boxes[1].LL.y)) {
flip = 1;
for (bi = 0; bi < boxn; bi++) {
double v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
}
else flip = 0;
if (agtail(realedge) != aghead(realedge)) {
/* I assume that the path goes either down only or
up - right - down */
for (bi = 0, pi = 0; bi < boxn; bi++) {
next = prev = 0;
if (bi > 0)
prev = (boxes[bi].LL.y > boxes[bi - 1].LL.y) ? -1 : 1;
if (bi < boxn - 1)
next = (boxes[bi + 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
else {
if (!(prev == -1 && next == -1))
abort();
}
}
for (bi = boxn - 1; bi >= 0; bi--) {
next = prev = 0;
if (bi < boxn - 1)
prev = (boxes[bi].LL.y > boxes[bi + 1].LL.y) ? -1 : 1;
if (bi > 0)
next = (boxes[bi - 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1 ) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
else {
if (!(prev == -1 && next == -1)) {
/* it went badly, e.g. degenerate box in boxlist */
*npoints = 0;
abort(); /* for correctness sake, it's best to just stop */
return ps; /* could also be reported as a lost edge (no spline) */
}
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
}
}
else {
abort();
}
if (flip) {
int i;
for (bi = 0; bi < boxn; bi++) {
int v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
for (i = 0; i < pi; i++)
polypoints[i].y *= -1;
}
for (bi = 0; bi < boxn; bi++)
boxes[bi].LL.x = INT_MAX, boxes[bi].UR.x = INT_MIN;
poly.ps = polypoints, poly.pn = pi;
eps[0].x = pp->start.p.x, eps[0].y = pp->start.p.y;
eps[1].x = pp->end.p.x, eps[1].y = pp->end.p.y;
if (Pshortestpath(&poly, eps, &pl) == -1)
abort();
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintpoly(poly);
psprintline(pl);
}
#endif
if (polyline) {
make_polyline (pl, &spl);
}
else {
if (poly.pn > edgen) {
edges = ALLOC(poly.pn, edges, Pedge_t);
edgen = poly.pn;
}
for (edgei = 0; edgei < poly.pn; edgei++) {
edges[edgei].a = polypoints[edgei];
edges[edgei].b = polypoints[(edgei + 1) % poly.pn];
}
if (pp->start.constrained) {
evs[0].x = cos(pp->start.theta);
evs[0].y = sin(pp->start.theta);
} else
evs[0].x = evs[0].y = 0;
if (pp->end.constrained) {
evs[1].x = -cos(pp->end.theta);
evs[1].y = -sin(pp->end.theta);
} else
evs[1].x = evs[1].y = 0;
if (Proutespline(edges, poly.pn, pl, evs, &spl) == -1)
abort();
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintspline(spl);
psprintinit(0);
}
#endif
}
mkspacep(spl.pn);
for (bi = 0; bi < boxn; bi++) {
boxes[bi].LL.x = INT_MAX;
boxes[bi].UR.x = INT_MIN;
}
for (splinepi = 0; splinepi < spl.pn; splinepi++) {
ps[splinepi] = spl.ps[splinepi];
}
REDO:
for (splinepi = 0; splinepi + 3 < spl.pn; splinepi += 3) {
int num_div = delta * boxn;
for (si = 0; si <= num_div; si++) {
t = si / (double)num_div;
sp[0] = ps[splinepi];
sp[1] = ps[splinepi + 1];
sp[2] = ps[splinepi + 2];
sp[3] = ps[splinepi + 3];
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
sp[1].x = sp[1].x + t * (sp[2].x - sp[1].x);
sp[1].y = sp[1].y + t * (sp[2].y - sp[1].y);
sp[2].x = sp[2].x + t * (sp[3].x - sp[2].x);
sp[2].y = sp[2].y + t * (sp[3].y - sp[2].y);
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
sp[1].x = sp[1].x + t * (sp[2].x - sp[1].x);
sp[1].y = sp[1].y + t * (sp[2].y - sp[1].y);
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
for (bi = 0; bi < boxn; bi++) {
/* this tested ok on 64bit machines, but on 32bit we need this FUDGE
* or graphs/directed/records.gv fails */
#define FUDGE .0001
if (sp[0].y <= boxes[bi].UR.y+FUDGE && sp[0].y >= boxes[bi].LL.y-FUDGE) {
if (boxes[bi].LL.x > sp[0].x)
boxes[bi].LL.x = sp[0].x;
if (boxes[bi].UR.x < sp[0].x)
boxes[bi].UR.x = sp[0].x;
}
}
}
}
/* The following check is necessary because if a box is not very
* high, it is possible that the sampling above might miss it.
* Therefore, we make the sample finer until all boxes have
* valid values. cf. bug 456. Would making sp[] pointfs help?
*/
for (bi = 0; bi < boxn; bi++) {
/* these fp equality tests are used only to detect if the
* values have been changed since initialization - ok */
if ((boxes[bi].LL.x == INT_MAX) || (boxes[bi].UR.x == INT_MIN)) {
delta *= 2;
goto REDO;
}
}
*npoints = spl.pn;
#ifdef DEBUG
if (GD_showboxes(realedge->head->graph) == 2 ||
GD_showboxes(realedge->tail->graph) == 2 ||
ED_showboxes(realedge) == 2 ||
ND_showboxes(realedge->head) == 2 ||
ND_showboxes(realedge->tail) == 2)
printboxes(boxn, boxes);
#endif
return ps;
}
/**
* <JA>
* @brief jconf設定パラメータを最終的に決定する
*
* この関数は，jconf ファイルやコマンドオプションによって与えられた
* jconf 内のパラメータについて精査を行う. 具体的には，値の範囲のチェッ
* クや，競合のチェック，設定から算出される各種パラメータの計算，使用
* するモデルに対する指定の有効性などをチェックする.
*
* この関数は，アプリケーションによって jconf の各値の指定が終了した直後，
* エンジンインスタンスの作成やモデルのロードが行われる前に呼び出される
* べきである.
*
* </JA>
* <EN>
* @brief Check and finalize jconf parameters.
*
* This functions parse through the global jconf configuration parameters.
* This function checks for value range of variables, file existence,
* competing specifications among variables or between variables and models,
* calculate some parameters from the given values, etc.
*
* This function should be called just after all values are set by
* jconf, command argument or by user application, and before creating
* engine instance and loading models.
*
* </EN>
*
* @param jconf [i/o] global jconf configuration structure
*
* @return TRUE when all check has been passed, or FALSE if not passed.
*
* @callgraph
* @callergraph
* @ingroup jconf
*/
boolean
j_jconf_finalize(Jconf *jconf)
{
boolean ok_p;
JCONF_LM *lm;
JCONF_AM *am;
JCONF_SEARCH *s, *hs;
ok_p = TRUE;
/* update and tailor configuration */
/* if a search config has progout_flag enabled, set it to all config */
hs = NULL;
for(s=jconf->search_root;s;s=s->next) {
if (s->output.progout_flag) {
hs = s;
break;
}
}
if (hs != NULL) {
for(s=jconf->search_root;s;s=s->next) {
s->output.progout_flag = hs->output.progout_flag;
s->output.progout_interval = hs->output.progout_interval;
}
}
/* if an instance has short-pause segmentation enabled,
set it to global opt for parameter handling
(only a recognizer with this option will decide the segmentation,
but the segmentation should be synchronized for all the recognizer)
*/
for(s=jconf->search_root;s;s=s->next) {
if (s->successive.enabled) {
jconf->decodeopt.segment = TRUE;
break;
}
}
#ifdef GMM_VAD
/* if GMM VAD enabled, set it to global */
if (jconf->reject.gmm_filename) {
jconf->decodeopt.segment = TRUE;
}
#endif
for(lm = jconf->lm_root; lm; lm = lm->next) {
if (lm->lmtype == LM_UNDEF) {
/* determine LM type from the specified LM files */
if (lm->ngram_filename_lr_arpa || lm->ngram_filename_rl_arpa || lm->ngram_filename) {
/* n-gram specified */
lm->lmtype = LM_PROB;
lm->lmvar = LM_NGRAM;
}
if (lm->gramlist_root) {
/* DFA grammar specified */
if (lm->lmtype != LM_UNDEF) {
jlog("ERROR: m_chkparam: LM conflicts: several LM of different type specified?\n");
return FALSE;
}
lm->lmtype = LM_DFA;
lm->lmvar = LM_DFA_GRAMMAR;
}
if (lm->dfa_filename) {
/* DFA grammar specified by "-dfa" */
if (lm->lmtype != LM_UNDEF && lm->lmvar != LM_DFA_GRAMMAR) {
jlog("ERROR: m_chkparam: LM conflicts: several LM of different type specified?\n");
return FALSE;
}
lm->lmtype = LM_DFA;
lm->lmvar = LM_DFA_GRAMMAR;
}
if (lm->wordlist_root) {
/* word list specified */
if (lm->lmtype != LM_UNDEF) {
jlog("ERROR: m_chkparam: LM conflicts: several LM of different type specified?\n");
return FALSE;
}
lm->lmtype = LM_DFA;
lm->lmvar = LM_DFA_WORD;
}
}
if (lm->lmtype == LM_UNDEF) { /* an LM is not specified */
jlog("ERROR: m_chkparam: you should specify at least one LM to run Julius!\n");
return FALSE;
}
if (lm->lmtype == LM_PROB) {
if (lm->dictfilename == NULL) {
jlog("ERROR: m_chkparam: needs dictionary file (-v dict_file)\n");
ok_p = FALSE;
}
}
/* file existence check */
if (lm->dictfilename != NULL)
if (!checkpath(lm->dictfilename)) ok_p = FALSE;
if (lm->ngram_filename != NULL)
if (!checkpath(lm->ngram_filename)) ok_p = FALSE;
if (lm->ngram_filename_lr_arpa != NULL)
if (!checkpath(lm->ngram_filename_lr_arpa)) ok_p = FALSE;
if (lm->ngram_filename_rl_arpa != NULL)
if (!checkpath(lm->ngram_filename_rl_arpa)) ok_p = FALSE;
if (lm->dfa_filename != NULL)
if (!checkpath(lm->dfa_filename)) ok_p = FALSE;
}
for(am = jconf->am_root; am; am = am->next) {
/* check if needed files are specified */
if (am->hmmfilename == NULL) {
jlog("ERROR: m_chkparam: needs HMM definition file (-h hmmdef_file)\n");
ok_p = FALSE;
}
/* file existence check */
if (am->hmmfilename != NULL)
if (!checkpath(am->hmmfilename)) ok_p = FALSE;
if (am->mapfilename != NULL)
if (!checkpath(am->mapfilename)) ok_p = FALSE;
if (am->hmm_gs_filename != NULL)
if (!checkpath(am->hmm_gs_filename)) ok_p = FALSE;
/* cmn{save,load}_filename allows missing file (skipped if missing) */
if (am->frontend.ssload_filename != NULL)
if (!checkpath(am->frontend.ssload_filename)) ok_p = FALSE;
}
if (jconf->reject.gmm_filename != NULL)
if (!checkpath(jconf->reject.gmm_filename)) ok_p = FALSE;
if (jconf->input.inputlist_filename != NULL) {
if (jconf->input.speech_input != SP_RAWFILE && jconf->input.speech_input != SP_MFCFILE && jconf->input.speech_input != SP_OUTPROBFILE) {
jlog("WARNING: m_chkparam: not file input, \"-filelist %s\" ignored\n", jconf->input.inputlist_filename);
} else {
if (!checkpath(jconf->input.inputlist_filename)) ok_p = FALSE;
}
}
/* set default realtime flag according to input mode */
if (jconf->decodeopt.force_realtime_flag) {
if (jconf->input.type == INPUT_VECTOR) {
jlog("WARNING: m_chkparam: real-time concurrent processing is not needed on feature vector input\n");
jlog("WARNING: m_chkparam: real-time flag has turned off\n");
jconf->decodeopt.realtime_flag = FALSE;
} else {
jconf->decodeopt.realtime_flag = jconf->decodeopt.forced_realtime;
}
}
/* check for cmn */
if (jconf->decodeopt.realtime_flag) {
for(am = jconf->am_root; am; am = am->next) {
if (am->analysis.cmn_update == FALSE && am->analysis.cmnload_filename == NULL) {
jlog("ERROR: m_chkparam: when \"-cmnnoupdate\", initial cepstral normalisation data should be given by \"-cmnload\"\n");
ok_p = FALSE;
}
}
}
/* set values for search config */
for(s=jconf->search_root;s;s=s->next) {
lm = s->lmconf;
am = s->amconf;
/* force context dependency handling flag for word-recognition mode */
if (lm->lmtype == LM_DFA && lm->lmvar == LM_DFA_WORD) {
/* disable inter-word context dependent handling ("-no_ccd") */
s->ccd_handling = FALSE;
s->force_ccd_handling = TRUE;
/* force 1pass ("-1pass") */
s->compute_only_1pass = TRUE;
}
/* set default iwcd1 method from lm */
/* WARNING: THIS WILL BEHAVE WRONG IF MULTIPLE LM TYPE SPECIFIED */
/* RECOMMEND USING EXPLICIT OPTION */
if (am->iwcdmethod == IWCD_UNDEF) {
switch(lm->lmtype) {
case LM_PROB:
am->iwcdmethod = IWCD_NBEST; break;
case LM_DFA:
am->iwcdmethod = IWCD_AVG; break;
}
}
}
/* check option validity with the current lm type */
/* just a warning message for user */
for(s=jconf->search_root;s;s=s->next) {
lm = s->lmconf;
am = s->amconf;
if (lm->lmtype != LM_PROB) {
/* in case not a probabilistic model */
if (s->lmp.lmp_specified) {
jlog("WARNING: m_chkparam: \"-lmp\" only for N-gram, ignored\n");
}
if (s->lmp.lmp2_specified) {
jlog("WARNING: m_chkparam: \"-lmp2\" only for N-gram, ignored\n");
}
if (s->lmp.lm_penalty_trans != 0.0) {
jlog("WARNING: m_chkparam: \"-transp\" only for N-gram, ignored\n");
}
if (lm->head_silname && !strmatch(lm->head_silname, BEGIN_WORD_DEFAULT)) {
jlog("WARNING: m_chkparam: \"-silhead\" only for N-gram, ignored\n");
}
if (lm->tail_silname && !strmatch(lm->tail_silname, END_WORD_DEFAULT)) {
jlog("WARNING: m_chkparam: \"-siltail\" only for N-gram, ignored\n");
}
if (lm->enable_iwspword) {
jlog("WARNING: m_chkparam: \"-iwspword\" only for N-gram, ignored\n");
}
if (lm->iwspentry && !strmatch(lm->iwspentry, IWSPENTRY_DEFAULT)) {
jlog("WARNING: m_chkparam: \"-iwspentry\" only for N-gram, ignored\n");
}
#ifdef HASH_CACHE_IW
if (s->pass1.iw_cache_rate != 10) {
jlog("WARNING: m_chkparam: \"-iwcache\" only for N-gram, ignored\n");
}
#endif
#ifdef SEPARATE_BY_UNIGRAM
if (lm->separate_wnum != 150) {
jlog("WARNING: m_chkparam: \"-sepnum\" only for N-gram, ignored\n");
}
#endif
}
if (lm->lmtype != LM_DFA) {
/* in case not a deterministic model */
if (s->pass2.looktrellis_flag) {
jlog("WARNING: m_chkparam: \"-looktrellis\" only for grammar, ignored\n");
}
if (s->output.multigramout_flag) {
jlog("WARNING: m_chkparam: \"-multigramout\" only for grammar, ignored\n");
}
if (s->lmp.penalty1 != 0.0) {
jlog("WARNING: m_chkparam: \"-penalty1\" only for grammar, ignored\n");
}
if (s->lmp.penalty2 != 0.0) {
jlog("WARNING: m_chkparam: \"-penalty2\" only for grammar, ignored\n");
}
}
}
if (!ok_p) {
jlog("ERROR: m_chkparam: could not pass parameter check\n");
} else {
jlog("STAT: jconf successfully finalized\n");
}
if (debug2_flag) {
print_jconf_overview(jconf);
}
return ok_p;
}
static int
mountfs(const char *vfstype, const char *spec, const char *name, int flags,
const char *options, const char *mntopts)
{
/* List of directories containing mount_xxx subcommands. */
static const char *edirs[] = {
_PATH_SBIN,
_PATH_USRSBIN,
NULL
};
const char *argv[100], **edir;
struct statfs sf;
pid_t pid;
int argc, i, status;
char *optbuf, execname[MAXPATHLEN + 1], mntpath[MAXPATHLEN];
#if __GNUC__
(void)&optbuf;
(void)&name;
#endif
/* resolve the mountpoint with realpath(3) */
checkpath(name, mntpath);
name = mntpath;
if (mntopts == NULL)
mntopts = "";
if (options == NULL) {
if (*mntopts == '\0') {
options = "rw";
} else {
options = mntopts;
mntopts = "";
}
}
optbuf = catopt(xstrdup(mntopts), options);
if (strcmp(name, "/") == 0)
flags |= MNT_UPDATE;
if (flags & MNT_FORCE)
optbuf = catopt(optbuf, "force");
if (flags & MNT_RDONLY)
optbuf = catopt(optbuf, "ro");
/*
* XXX
* The mount_mfs (newfs) command uses -o to select the
* optimization mode. We don't pass the default "-o rw"
* for that reason.
*/
if (flags & MNT_UPDATE)
optbuf = catopt(optbuf, "update");
argc = 0;
argv[argc++] = vfstype;
mangle(optbuf, &argc, argv);
argv[argc++] = spec;
argv[argc++] = name;
argv[argc] = NULL;
if (debug) {
printf("exec: mount_%s", vfstype);
for (i = 1; i < argc; i++)
printf(" %s", argv[i]);
printf("\n");
return (0);
}
switch (pid = fork()) {
case -1: /* Error. */
warn("fork");
free(optbuf);
return (1);
case 0: /* Child. */
/* Go find an executable. */
for (edir = edirs; *edir; edir++) {
snprintf(execname,
sizeof(execname), "%s/mount_%s", *edir, vfstype);
execv(execname, __DECONST(char * const *, argv));
}
if (errno == ENOENT) {
int len = 0;
char *cp;
for (edir = edirs; *edir; edir++)
len += strlen(*edir) + 2; /* ", " */
if ((cp = malloc(len)) == NULL)
errx(1, "malloc failed");
cp[0] = '\0';
for (edir = edirs; *edir; edir++) {
strcat(cp, *edir);
if (edir[1] != NULL)
strcat(cp, ", ");
}
warn("exec mount_%s not found in %s", vfstype, cp);
}
exit(1);
/* NOTREACHED */
default: /* Parent. */
free(optbuf);
if (waitpid(pid, &status, 0) < 0) {
warn("waitpid");
return (1);
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0)
return (WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
warnx("%s: %s", name, sys_siglist[WTERMSIG(status)]);
return (1);
}
if (verbose) {
if (statfs(name, &sf) < 0) {
warn("statfs %s", name);
return (1);
}
if (fstab_style)
putfsent(&sf);
else
prmount(&sf);
}
break;
}
return (0);
}
/* routesplines:
* Route a path using the path info in pp. This includes start and end points
* plus a collection of contiguous boxes contain the terminal points. The boxes
* are converted into a containing polygon. A shortest path is constructed within
* the polygon from between the terminal points. If polyline is true, this path
* is converted to a spline representation. Otherwise, we call the path planner to
* convert the polyline into a smooth spline staying within the polygon. In both
* cases, the function returns an array of the computed control points. The number
* of these points is given in npoints.
*
* Note that the returned points are stored in a single array, so the points must be
* used before another call to this function.
*
* During cleanup, the function determines the x-extent of the spline in the box, so
* the box can be shrunk to the minimum width. The extra space can then be used by other
* edges.
*
* If a catastrophic error, return NULL.
*/
static pointf *_routesplines(path * pp, int *npoints, int polyline)
{
Ppoly_t poly;
Ppolyline_t pl, spl;
int splinepi;
Ppoint_t eps[2];
Pvector_t evs[2];
int edgei, prev, next;
int pi, bi;
boxf *boxes;
int boxn;
edge_t* realedge;
int flip;
int loopcnt, delta = INIT_DELTA;
boolean unbounded;
nedges++;
nboxes += pp->nbox;
for (realedge = (edge_t *) pp->data;
#ifdef NOTNOW
origedge = realedge;
#endif
realedge && ED_edge_type(realedge) != NORMAL;
realedge = ED_to_orig(realedge));
if (!realedge) {
agerr(AGERR, "in routesplines, cannot find NORMAL edge\n");
return NULL;
}
boxes = pp->boxes;
boxn = pp->nbox;
if (checkpath(boxn, boxes, pp))
return NULL;
#ifdef DEBUG
if (debugleveln(realedge, 1))
printboxes(boxn, boxes);
if (debugleveln(realedge, 3)) {
psprintinit(1);
psprintboxes(boxn, boxes);
}
#endif
if (boxn * 8 > polypointn) {
polypoints = ALLOC(boxn * 8, polypoints, Ppoint_t);
polypointn = boxn * 8;
}
if ((boxn > 1) && (boxes[0].LL.y > boxes[1].LL.y)) {
flip = 1;
for (bi = 0; bi < boxn; bi++) {
double v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
}
else flip = 0;
if (agtail(realedge) != aghead(realedge)) {
/* I assume that the path goes either down only or
up - right - down */
for (bi = 0, pi = 0; bi < boxn; bi++) {
next = prev = 0;
if (bi > 0)
prev = (boxes[bi].LL.y > boxes[bi - 1].LL.y) ? -1 : 1;
if (bi < boxn - 1)
next = (boxes[bi + 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
else {
if (!(prev == -1 && next == -1)) {
agerr(AGERR, "in routesplines, illegal values of prev %d and next %d, line %d\n", prev, next, __LINE__);
return NULL;
}
}
}
for (bi = boxn - 1; bi >= 0; bi--) {
next = prev = 0;
if (bi < boxn - 1)
prev = (boxes[bi].LL.y > boxes[bi + 1].LL.y) ? -1 : 1;
if (bi > 0)
next = (boxes[bi - 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1 ) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
else {
if (!(prev == -1 && next == -1)) {
/* it went badly, e.g. degenerate box in boxlist */
agerr(AGERR, "in routesplines, illegal values of prev %d and next %d, line %d\n", prev, next, __LINE__);
return NULL; /* for correctness sake, it's best to just stop */
}
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
}
}
else {
agerr(AGERR, "in routesplines, edge is a loop at %s\n", agnameof(aghead(realedge)));
return NULL;
}
if (flip) {
int i;
for (bi = 0; bi < boxn; bi++) {
int v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
for (i = 0; i < pi; i++)
polypoints[i].y *= -1;
}
for (bi = 0; bi < boxn; bi++)
boxes[bi].LL.x = INT_MAX, boxes[bi].UR.x = INT_MIN;
poly.ps = polypoints, poly.pn = pi;
eps[0].x = pp->start.p.x, eps[0].y = pp->start.p.y;
eps[1].x = pp->end.p.x, eps[1].y = pp->end.p.y;
if (Pshortestpath(&poly, eps, &pl) < 0) {
agerr(AGERR, "in routesplines, Pshortestpath failed\n");
return NULL;
}
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintpoly(poly);
psprintline(pl);
}
#endif
if (polyline) {
make_polyline (pl, &spl);
}
else {
if (poly.pn > edgen) {
edges = ALLOC(poly.pn, edges, Pedge_t);
edgen = poly.pn;
}
for (edgei = 0; edgei < poly.pn; edgei++) {
edges[edgei].a = polypoints[edgei];
edges[edgei].b = polypoints[(edgei + 1) % poly.pn];
}
if (pp->start.constrained) {
evs[0].x = cos(pp->start.theta);
evs[0].y = sin(pp->start.theta);
} else
evs[0].x = evs[0].y = 0;
if (pp->end.constrained) {
evs[1].x = -cos(pp->end.theta);
evs[1].y = -sin(pp->end.theta);
} else
evs[1].x = evs[1].y = 0;
if (Proutespline(edges, poly.pn, pl, evs, &spl) < 0) {
agerr(AGERR, "in routesplines, Proutespline failed\n");
return NULL;
}
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintspline(spl);
psprintinit(0);
}
#endif
}
if (mkspacep(spl.pn))
return NULL; /* Bailout if no memory left */
for (bi = 0; bi < boxn; bi++) {
boxes[bi].LL.x = INT_MAX;
boxes[bi].UR.x = INT_MIN;
}
unbounded = TRUE;
for (splinepi = 0; splinepi < spl.pn; splinepi++) {
ps[splinepi] = spl.ps[splinepi];
}
for (loopcnt = 0; unbounded && (loopcnt < LOOP_TRIES); loopcnt++) {
limitBoxes (boxes, boxn, ps, spl.pn, delta);
/* The following check is necessary because if a box is not very
* high, it is possible that the sampling above might miss it.
* Therefore, we make the sample finer until all boxes have
* valid values. cf. bug 456. Would making sp[] pointfs help?
*/
for (bi = 0; bi < boxn; bi++) {
/* these fp equality tests are used only to detect if the
* values have been changed since initialization - ok */
if ((boxes[bi].LL.x == INT_MAX) || (boxes[bi].UR.x == INT_MIN)) {
delta *= 2; /* try again with a finer interval */
if (delta > INT_MAX/boxn) /* in limitBoxes, boxn*delta must fit in an int, so give up */
loopcnt = LOOP_TRIES;
break;
}
}
if (bi == boxn)
unbounded = FALSE;
}
if (unbounded) {
/* Either an extremely short, even degenerate, box, or some failure with the path
* planner causing the spline to miss some boxes. In any case, use the shortest path
* to bound the boxes. This will probably mean a bad edge, but we avoid an infinite
* loop and we can see the bad edge, and even use the showboxes scaffolding.
*/
Ppolyline_t polyspl;
agerr(AGWARN, "Unable to reclaim box space in spline routing for edge \"%s\" -> \"%s\". Something is probably seriously wrong.\n", agnameof(agtail(realedge)), agnameof(aghead(realedge)));
make_polyline (pl, &polyspl);
limitBoxes (boxes, boxn, polyspl.ps, polyspl.pn, INIT_DELTA);
free (polyspl.ps);
}
*npoints = spl.pn;
#ifdef DEBUG
if (GD_showboxes(agraphof(aghead(realedge))) == 2 ||
GD_showboxes(agraphof(agtail(realedge))) == 2 ||
ED_showboxes(realedge) == 2 ||
ND_showboxes(aghead(realedge)) == 2 ||
ND_showboxes(agtail(realedge)) == 2)
printboxes(boxn, boxes);
#endif
return ps;
}
point *routesplines(path * pp, int *npoints)
{
Ppoly_t poly;
Ppolyline_t pl, spl;
int splinepi;
Ppoint_t eps[2];
Pvector_t evs[2];
int edgei, prev, next;
point sp[4];
int pi, bi, si;
double t;
box *boxes;
int boxn;
edge_t* realedge;
int flip;
nedges++;
nboxes += pp->nbox;
for (realedge = (edge_t *) pp->data;
#ifdef NOTNOW
origedge = realedge;
#endif
realedge && ED_edge_type(realedge) != NORMAL;
realedge = ED_to_orig(realedge));
if (!realedge) {
agerr(AGERR, "in routesplines, cannot find NORMAL edge\n");
abort();
}
boxes = pp->boxes;
boxn = pp->nbox;
checkpath(boxn, boxes, pp);
#ifdef DEBUG
if (debugleveln(realedge, 1))
printboxes(boxn, boxes);
if (debugleveln(realedge, 3)) {
psprintinit(1);
psprintboxes(boxn, boxes);
}
#endif
if (boxn * 8 > polypointn) {
polypoints = ALLOC(boxn * 8, polypoints, Ppoint_t);
polypointn = boxn * 8;
}
if ((boxn > 1) && (boxes[0].LL.y > boxes[1].LL.y)) {
flip = 1;
for (bi = 0; bi < boxn; bi++) {
int v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
}
else flip = 0;
if (realedge->tail != realedge->head) {
/* I assume that the path goes either down only or
up - right - down */
for (bi = 0, pi = 0; bi < boxn; bi++) {
next = prev = 0;
if (bi > 0)
prev = (boxes[bi].LL.y > boxes[bi - 1].LL.y) ? -1 : 1;
if (bi < boxn - 1)
next = (boxes[bi + 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
else {
if (!(prev == -1 && next == -1))
abort();
}
}
for (bi = boxn - 1; bi >= 0; bi--) {
next = prev = 0;
if (bi < boxn - 1)
prev = (boxes[bi].LL.y > boxes[bi + 1].LL.y) ? -1 : 1;
if (bi > 0)
next = (boxes[bi - 1].LL.y > boxes[bi].LL.y) ? 1 : -1;
if (prev != next) {
if (next == -1 || prev == 1 ) {
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
} else {
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
}
else if (prev == 0) { /* single box */
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
}
else {
if (!(prev == -1 && next == -1)) {
/* it went badly, e.g. degenerate box in boxlist */
*npoints = 0;
abort(); /* for correctness sake, it's best to just stop */
return ps; /* could also be reported as a lost edge (no spline) */
}
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].LL.y;
polypoints[pi].x = boxes[bi].UR.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].UR.y;
polypoints[pi].x = boxes[bi].LL.x;
polypoints[pi++].y = boxes[bi].LL.y;
}
}
}
else {
#ifdef OBSOLETE
/* new, more generalized approach for self-edges. We do not
assume any monotonicity about the box path, only that it
is simply connected. We build up the constraint poly by
walking the box path from one end to the other and back
in the recursive function append(). A better approach to all
of this might be to dispense with the box paths altogether
and just compute the constraint poly directly, but this
needs to be done as part of a more thorough overhaul. */
point p0, p1;
box b0, b1;
b0 = pp->boxes[0];
b1 = pp->boxes[1];
/* determine 'starting' segment (side of b0) for box path search */
if (b0.UR.x == b1.LL.x) {
p0 = b0.LL;
p1 = mkpt(b0.LL.x, b0.UR.y);
} else if (b0.LL.y == b1.UR.y) {
p0 = mkpt(b0.LL.x, b0.UR.y);
p1 = b0.UR;
} else if (b0.LL.x == b1.UR.x) {
p0 = b0.UR;
p1 = mkpt(b0.UR.x, b0.LL.y);
} else if (b0.UR.y == b1.LL.y) {
p0 = mkpt(b0.UR.x, b0.LL.y);
p1 = b0.LL;
} else
abort();
pi = append(pp, 0, p0, p1, 0);
#else
abort();
#endif
}
if (flip) {
int i;
for (bi = 0; bi < boxn; bi++) {
int v = boxes[bi].UR.y;
boxes[bi].UR.y = -1*boxes[bi].LL.y;
boxes[bi].LL.y = -v;
}
for (i = 0; i < pi; i++)
polypoints[i].y *= -1;
}
for (bi = 0; bi < boxn; bi++)
boxes[bi].LL.x = INT_MAX, boxes[bi].UR.x = INT_MIN;
poly.ps = polypoints, poly.pn = pi;
eps[0].x = pp->start.p.x, eps[0].y = pp->start.p.y;
eps[1].x = pp->end.p.x, eps[1].y = pp->end.p.y;
if (Pshortestpath(&poly, eps, &pl) == -1)
abort();
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintpoly(poly);
psprintline(pl);
}
#endif
if (poly.pn > edgen) {
edges = ALLOC(poly.pn, edges, Pedge_t);
edgen = poly.pn;
}
for (edgei = 0; edgei < poly.pn; edgei++) {
edges[edgei].a = polypoints[edgei];
edges[edgei].b = polypoints[(edgei + 1) % poly.pn];
}
if (pp->start.constrained) {
evs[0].x = cos(pp->start.theta);
evs[0].y = sin(pp->start.theta);
} else
evs[0].x = evs[0].y = 0;
if (pp->end.constrained) {
evs[1].x = -cos(pp->end.theta);
evs[1].y = -sin(pp->end.theta);
} else
evs[1].x = evs[1].y = 0;
if (Proutespline(edges, poly.pn, pl, evs, &spl) == -1)
abort();
#ifdef DEBUG
if (debugleveln(realedge, 3)) {
psprintspline(spl);
psprintinit(0);
}
#endif
mkspacep(spl.pn);
for (bi = 0; bi <= boxn; bi++) {
boxes[bi].LL.x = INT_MAX;
boxes[bi].UR.x = INT_MIN;
}
for (splinepi = 0; splinepi < spl.pn; splinepi++) {
ps[splinepi].x = spl.ps[splinepi].x;
ps[splinepi].y = spl.ps[splinepi].y;
}
for (splinepi = 0; splinepi + 3 < spl.pn; splinepi += 3) {
for (si = 0; si <= 10 * boxn; si++) {
t = si / (10.0 * boxn);
sp[0] = ps[splinepi];
sp[1] = ps[splinepi + 1];
sp[2] = ps[splinepi + 2];
sp[3] = ps[splinepi + 3];
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
sp[1].x = sp[1].x + t * (sp[2].x - sp[1].x);
sp[1].y = sp[1].y + t * (sp[2].y - sp[1].y);
sp[2].x = sp[2].x + t * (sp[3].x - sp[2].x);
sp[2].y = sp[2].y + t * (sp[3].y - sp[2].y);
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
sp[1].x = sp[1].x + t * (sp[2].x - sp[1].x);
sp[1].y = sp[1].y + t * (sp[2].y - sp[1].y);
sp[0].x = sp[0].x + t * (sp[1].x - sp[0].x);
sp[0].y = sp[0].y + t * (sp[1].y - sp[0].y);
for (bi = 0; bi < boxn; bi++) {
if (sp[0].y <= boxes[bi].UR.y && sp[0].y >= boxes[bi].LL.y) {
if (boxes[bi].LL.x > sp[0].x)
boxes[bi].LL.x = sp[0].x;
if (boxes[bi].UR.x < sp[0].x)
boxes[bi].UR.x = sp[0].x;
}
}
}
}
*npoints = spl.pn;
#ifdef DEBUG
if (GD_showboxes(realedge->head->graph) == 2 ||
GD_showboxes(realedge->tail->graph) == 2 ||
ED_showboxes(realedge) == 2 ||
ND_showboxes(realedge->head) == 2 ||
ND_showboxes(realedge->tail) == 2)
printboxes(boxn, boxes);
#endif
return ps;
}
/*
* Process incoming file information header
*/
static int procheader(char *name)
{
char *openmode, *p;
closeok = 0;
/* set default parameters and overrides */
openmode = "w";
Thisbinary = (!Rxascii) || Rxbinary;
if (Lzmanag)
zmanag = Lzmanag;
/*
* Process ZMODEM remote file management requests
*/
if (!Rxbinary && zconv == ZCNL) /* Remote ASCII override */
Thisbinary = 0;
if (zconv == ZCBIN) /* Remote Binary override */
Thisbinary = TRUE;
else if (zmanag == ZMAPND)
openmode = "a";
if (try_resume)
zconv = ZCRESUM;
/* Check for existing file */
if (zconv != ZCRESUM && !Rxclob && (zmanag & ZMMASK) != ZMCLOB
&& (fout = fopen(name, "r"))) {
fclose(fout);
return ERROR;
}
Bytesleft = DEFBYTL;
Filemode = 0;
Modtime = 0L;
p = name + 1 + strlen(name);
if (*p) { /* file coming from Unix or DOS system */
sscanf(p, "%ld%lo%o", &Bytesleft, &Modtime, &Filemode);
if (Filemode & UNIXFILE)
++Thisbinary;
} else { /* File coming from CP/M system */
for (p = name; *p; ++p) /* change / to _ */
if (*p == '/')
*p = '_';
if (*--p == '.') /* zap trailing period */
*p = 0;
}
if (!Zmodem && MakeLCPathname && !IsAnyLower(name)
&& !(Filemode & UNIXFILE))
uncaps(name);
if (Topipe > 0) {
sprintf(Pathname, "%s %s", Progname + 2, name);
if (Verbose)
fprintf(stderr, "Topipe: %s %s\n",
Pathname, Thisbinary ? "BIN" : "ASCII");
if ((fout = popen(Pathname, "w")) == NULL)
return ERROR;
} else {
strcpy(Pathname, name);
if (Verbose)
fprintf(stderr, "\nReceiving: %s\n", name);
timing(1);
checkpath(name);
if (Nflag)
name = "/dev/null";
if (Thisbinary && zconv == ZCRESUM) {
struct stat st;
fout = fopen(name, "r+");
if (fout && 0 == fstat(fileno(fout), &st)) {
/* retransfer whole blocks */
rxbytes = st.st_size & ~(1024);
/* Bytesleft == filelength on remote */
if (rxbytes < Bytesleft) {
if (fseek(fout, rxbytes, 0)) {
fclose(fout);
return ZFERR;
}
}
goto buffer_it;
}
rxbytes = 0;
if (fout)
fclose(fout);
}
if (*pathsname) {
if (findfile(name, pathsname))
return ERROR;
}
if (*tempsname) {
char puskuri[300];
FILE *pathsfd;
if ((pathsfd = fopen(tempsname, "r")) != NULL) {
while (fgets(puskuri, 300, pathsfd)) {
char *s;
int filefd;
s = puskuri;
while (*s) {
if (*s == 13 || *s == 10)
*s = 0;
else
s++;
}
strcat(puskuri, name);
filefd = open(puskuri, O_RDONLY);
if (filefd != -1) {
close(filefd);
fclose(pathsfd);
return ERROR;
}
}
fclose(pathsfd);
}
}
strcpy(myname, name);
fout = fopen(name, openmode);
if (!fout) {
int e = errno;
fprintf(stderr, "lrz: cannot open %s: %s\n", name,
strerror(e));
return ERROR;
}
}
buffer_it:
closeok = 0;
if (Topipe == 0) {
static char *s = NULL;
if (!s) {
s = malloc(16384);
if (!s) {
fprintf(stderr, "lrz: out of memory\r\n");
exit(1);
}
#ifdef SETVBUF_REVERSED
setvbuf(fout, _IOFBF, s, 16384);
#else
setvbuf(fout, s, _IOFBF, 16384);
#endif
}
}
return OK;
}
//引数として、そのアリｋちゃんが作った巡回経路の距離の総和ant.tour_lenをわたす。
//分泌量はもしアリkちゃんが通った辺にはQ÷距離を返す。通ってなかったら０を返す。、
void delta_pheromon(double tour_len, city_a, city_b){
checkpath(city_a,city_b);
int Q=100; /定数