+ return ( pxmlapps );
+}
+
+unsigned char pnd_determine_mountpoint ( char *fullpath, char *r_mountpoint, unsigned int mountpoint_len ) {
+
+ // just cheap it, and call df like an idiot.
+
+ // Filesystem 1K-blocks Used Available Use% Mounted on
+
+ char cmd [ PATH_MAX ];
+ FILE *p;
+ char inbuf [ PATH_MAX ];
+
+ sprintf ( cmd, "/bin/df %s 2>/dev/null", fullpath );
+
+ if ( ( p = popen ( cmd, "r" ) ) ) {
+
+ // ignore title line; we really shoudl analyze it to figure out which column, but we make assumptions..
+ fgets ( inbuf, PATH_MAX, p );
+
+ if ( ! fgets ( inbuf, PATH_MAX, p ) ) {
+ pclose ( p );
+ return ( 0 );
+ }
+
+ pclose ( p );
+
+ // by now, good
+ char mount [ PATH_MAX ];
+ if ( sscanf ( inbuf, "%*s %*s %*s %*s %*s %s", mount ) != 1 ) {
+ return ( 0 );
+ }
+
+ if ( strlen ( mount ) < mountpoint_len ) {
+ strcpy ( r_mountpoint, mount );
+ return ( 1 );
+ }
+
+ } // if popen
+
+ return ( 0 );
+
+#if 0
+ struct stat fooby;
+
+ // can we even stat this file?
+ if ( stat ( fullpath, &fooby ) == 0 ) {
+ //dev_t st_dev; /* ID of device containing file */
+ //dev_t st_rdev; /* device ID (if special file) */
+
+ dev_t mount = fooby.st_dev;
+
+ DIR *d = opendir ( "/dev" );
+
+ if ( d ) {
+ struct dirent *de;
+ char path [ FILENAME_MAX ];
+
+ while ( de = readdir ( d ) ) {
+ sprintf ( path, "/dev/%s", de -> d_name );
+
+ if ( stat ( path, &fooby ) == 0 ) {
+
+ // finally, if we find the same major/minor pair in /dev, as we found for the target file, it means we found the right device
+ if ( fooby.st_rdev == mount ) {
+ printf ( "Device: %s\n", path );
+ }
+
+ } // if
+
+ } // while
+
+ } // opened /dev?
+
+ } // stat
+#endif
+
+ return ( 0 );
+}
+
+unsigned char pnd_filecopy ( char *sourcepath, char *targetpath ) {
+#define BITLEN (64*1024)
+ FILE *pnd, *target; // pnd == from, since I cribbed the code from pnd_desktop.c :/
+ unsigned char bits [ BITLEN ];
+ unsigned int bitlen;
+
+ pnd = fopen ( sourcepath, "rb" );
+
+ if ( ! pnd ) {
+ return ( 0 );
+ }
+
+ unsigned int len;
+
+ target = fopen ( targetpath, "wb" );
+
+ if ( ! target ) {
+ fclose ( pnd );
+ return ( 0 );
+ }
+
+ fseek ( pnd, 0, SEEK_END );
+ len = ftell ( pnd );
+ fseek ( pnd, 0, SEEK_SET );
+
+ while ( len ) {
+
+ if ( len > (BITLEN) ) {
+ bitlen = (BITLEN);
+ } else {
+ bitlen = len;
+ }
+
+ if ( fread ( bits, bitlen, 1, pnd ) != 1 ) {
+ fclose ( pnd );
+ fclose ( target );
+ unlink ( targetpath );
+ return ( 0 );
+ }
+
+ if ( fwrite ( bits, bitlen, 1, target ) != 1 ) {
+ fclose ( pnd );
+ fclose ( target );
+ unlink ( targetpath );
+ return ( 0 );
+ }
+
+ len -= bitlen;
+ } // while
+
+ fclose ( pnd );
+ fclose ( target );
+
+ return ( 1 );
+}
+
+unsigned char pnd_lock ( char *lockname ) {
+
+ if ( pnd_is_locked ( lockname ) ) {
+ return ( 0 ); // already locked
+ }
+
+ char fullpath [ PATH_MAX ];
+ int fd;
+
+ snprintf ( fullpath, PATH_MAX, "%s/%s", PND_LOCK_PATH, lockname );
+
+ if ( ( fd = creat ( fullpath, 0444 ) < 0 ) ) {
+ return ( 0 ); // error, yeah, I know, no way to know why it failed..
+ }
+
+ close ( fd );
+
+ return ( 1 );
+}
+
+time_t pnd_is_locked ( char *lockname ) {
+ char fullpath [ PATH_MAX ];
+ int rv;
+ snprintf ( fullpath, PATH_MAX, "%s/%s", PND_LOCK_PATH, lockname );
+
+ struct stat statbuf;
+ rv = stat ( fullpath, &statbuf );
+
+ if ( rv == ENOENT ) {
+ return ( 0 ); // file not existk, so no lock
+ } else if ( rv < 0 ) {
+ return ( 0 ); // assume unlocked for error, so app can continue?
+ }
+
+ return ( statbuf.st_mtime );
+}
+
+void pnd_unlock ( char *lockname ) {
+ char fullpath [ PATH_MAX ];
+ snprintf ( fullpath, PATH_MAX, "%s/%s", PND_LOCK_PATH, lockname );
+
+ unlink ( fullpath );
+
+ return;
+}
+
+unsigned char pnd_wait_for_unlock ( char *lockname, unsigned short int max, unsigned int usec_delta ) {
+
+ // check right off the top
+ if ( ! pnd_is_locked ( lockname ) ) {
+ return ( 1 ); // all clear!
+ }
+
+ unsigned short int count = 0;
+ while ( count < max ) {
+
+ if ( ! pnd_is_locked ( lockname ) ) {
+ return ( 1 ); // all clear!
+ }
+
+ usleep ( usec_delta );
+
+ count++;
+ }
+
+ return ( 0 );