#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <dirent.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <sys/param.h>

#include <errno.h>

#include <assert.h>

#include <pthread.h>

#include "platform.h"

#include "ui.h"

int file_exists(const char *fname)

{

struct stat statbuf;

return(stat(fname, &statbuf) == 0);

} /* file_exists */

int file_is_directory(const char *fname)

{

struct stat statbuf;

int retval = 0;

if (stat(fname, &statbuf) == 0)

{

if (S_ISDIR(statbuf.st_mode))

retval = 1;

} /* if */

return(retval);

} /* file_is_directory */

int file_is_symlink(const char *fname)

{

struct stat statbuf;

int retval = 0;

if (lstat(fname, &statbuf) == 0)

{

if (S_ISLNK(statbuf.st_mode))

retval = 1;

} /* if */

return(retval);

} /* file_is_symlink */

/* enumerate contents of (base) directory. */

file_list *make_filelist(const char *base)

{

file_list *retval = NULL;

file_list *l = NULL;

file_list *prev = NULL;

DIR *dir;

struct dirent *ent;

errno = 0;

dir = opendir(base);

if (dir == NULL)

{

_fatal("Error: could not read dir %s: %s.", base, strerror(errno));

return(NULL);

} /* if */

while (1)

{

ent = readdir(dir);

if (ent == NULL) /* we're done. */

break;

if (strcmp(ent->d_name, ".") == 0)

continue;

if (strcmp(ent->d_name, "..") == 0)

continue;

/*

* !!! FIXME: This is a workaround until symlinks are really

* !!! FIXME: supported...just pretend they don't exist for now. :(

*/

{

char buf[MAXPATHLEN];

snprintf(buf, sizeof (buf), "%s/%s", base, ent->d_name);

if (file_is_symlink(buf))

continue;

}

l = (file_list *) malloc(sizeof (file_list));

if (l == NULL)

{

_fatal("Error: out of memory.");

break;

} /* if */

l->fname = (char *) malloc(strlen(ent->d_name) + 1);

if (l->fname == NULL)

{

free(l);

_fatal("Error: out of memory.");

break;

} /* if */

strcpy(l->fname, ent->d_name);

if (retval == NULL)

retval = l;

else

prev->next = l;

prev = l;

l->next = NULL;

} /* while */

closedir(dir);

return(retval);

} /* make_filelist */

int get_file_size(const char *fname, long *fsize)

{

struct stat statbuf;

assert(fsize != NULL);

if (stat(fname, &statbuf) == -1)

{

_fatal("Error: failed to get filesize of [%s]: %s.",

fname, strerror(errno));

return(0);

} /* if */

*fsize = statbuf.st_size;

return(1);

} /* get_file_size */

char *get_realpath(const char *path)

{

char resolved_path[MAXPATHLEN];

char *retval = NULL;

errno = 0;

if (!realpath(path, resolved_path))

{

_fatal("Can't determine full path of [%s]: %s.",

path, strerror(errno));

return(NULL);

} /* if */

retval = malloc(strlen(resolved_path) + 1);

if (retval == NULL)

{

_fatal("Error: out of memory.");

return(NULL);

} /* if */

strcpy(retval, resolved_path);

return(retval);

} /* get_realpath */

#ifdef PLATFORM_MACOSX

#include <ApplicationServices/ApplicationServices.h>

static char *parse_xml(char *ptr, char **tag, char **val)

{

char *ptr2;

while ( (ptr = strchr(ptr, '<')) != NULL )

{

ptr++; /* skip past '<' to start of tag.*/

if (*ptr == '/') continue; /* prior endtag? */

if (*ptr == '!') continue; /* initial crap? */

if (*ptr == '?') continue; /* initial crap? */

*tag = ptr;

*(ptr-1) = '/'; /* prepend a '/' so we can search for the endtag. */

ptr2 = strchr(ptr, ' '); /* look for a space (tag attributes?) */

if ( (ptr = strchr(ptr, '>')) == NULL ) return(NULL);

if ((ptr2) && (ptr2 < ptr)) *ptr2 = '\0'; /* chop out attributes. */

*ptr = '\0'; /* chop off '<' at end of tag. */

*val = ptr + 1; /* (*val) == start of children of this tag. */

/* Catch <tagname/> tags... */

ptr2 = ptr - 1;

while ( (ptr2 != *tag) && (isspace(*ptr2)) )

ptr2--;

if ((ptr2 != *tag) && (*ptr2 == '/')) /* it's a <tag/> ... skip it. */

{

ptr = *val;

continue;

} /* if */

/* look for endtag... */

ptr++;

while ( (ptr = strstr(ptr, (*tag)-1)) != NULL )

{

if (*(ptr-1) != '<') { ptr++; continue; } /* false positive */

*(ptr-1) = '\0'; /* null-terminate tag's children. */

break;

} /* while */

/* return everything after this tag's children. */

return((ptr == NULL) ? NULL : ptr + 1);

} /* while */

return(NULL);

} /* parse_xml */

static char *find_info_plist_version(char *ptr)

{

int have_key = 0;

char *tag;

char *val;

while ( (ptr = parse_xml(ptr, &tag, &val)) != NULL )

{

if (have_key)

{

have_key = 0;

if (strcasecmp(tag, "string") == 0)

return(val);

} /* if */

if ((strcasecmp(tag, "plist") == 0) || (strcasecmp(tag, "dict") == 0))

{

ptr = val;

continue;

} /* if */

/* You should only use CFBundleShortVersionString, for various

* reasons not worth explaining here. CFBundleVersion is here

* for older products that need to update to the other tag.

*/

if (strcasecmp(tag,"key") == 0)

{

if (strcasecmp(val,"CFBundleVersion") == 0)

have_key = 1;

if (strcasecmp(val,"CFBundleShortVersionString") == 0)

have_key = 1;

} /* if */

} /* while */

return(NULL);

} /* find_info_plist_version */

/* !!! FIXME: Code duplication */

static char *find_info_plist_bundle_id(char *ptr)

{

int have_key = 0;

char *tag;

char *val;

while ( (ptr = parse_xml(ptr, &tag, &val)) != NULL )

{

if (have_key)

{

have_key = 0;

if (strcasecmp(tag, "string") == 0)

return(val);

} /* if */

if ((strcasecmp(tag, "plist") == 0) || (strcasecmp(tag, "dict") == 0))

{

ptr = val;

continue;

} /* if */

if (strcasecmp(tag,"key") == 0)

{

if (strcasecmp(val,"CFBundleIdentifier") == 0)

have_key = 1;

} /* if */

} /* while */

return(NULL);

} /* find_info_plist_version */

static int parse_info_dot_plist(const char *ident,

const char *version,

const char *newversion)

{

const char *fname = "Contents/Info.plist"; /* already chdir'd for this. */

char *mem = NULL;

char *ptr;

long fsize;

int retval = 0;

FILE *io = NULL;

if ( !get_file_size(fname, &fsize) ) goto parse_info_plist_bailed;

if ( (mem = malloc(fsize + 1)) == NULL ) goto parse_info_plist_bailed;

if ( (io = fopen(fname, "r")) == NULL ) goto parse_info_plist_bailed;

if ( (fread(mem, fsize, 1, io)) != 1 ) goto parse_info_plist_bailed;

fclose(io);

io = NULL;

mem[fsize] = '\0';

ptr = find_info_plist_bundle_id(mem);

if ((ptr == NULL) || (strcasecmp(ptr, ident) != 0))

{

int yes = ui_prompt_ny("We don't think we're looking at the right directory!"

" Are you SURE this is the right place?"

" If you aren't sure, clicking 'Yes' can destroy unrelated files!");

if (!yes)

{

_fatal("Stopping at user's request.");

free(mem);

return(0);

} /* if */

} /* if */

if ( (io = fopen(fname, "r")) == NULL ) goto parse_info_plist_bailed;

if ( (fread(mem, fsize, 1, io)) != 1 ) goto parse_info_plist_bailed;

fclose(io);

ptr = find_info_plist_version(mem);

if (ptr != NULL)

{

retval = version_ok(ptr, version);

if (retval == -1)

_fatal("You seem to be all patched up already!");

else if (retval == 0)

{

_fatal("This patch applies to version '%s', but you have '%s'.",

version, ptr);

} /* else */

} /* if */

parse_info_plist_bailed:

free(mem);

if (io != NULL)

fclose(io);

if (retval == 0) _fatal("Can't determine product's installed version.");

return(retval);

} /* parse_info_dot_plist */

int update_version(const char *ver)

{

const char *fname = "Contents/Info.plist"; /* already chdir'd for this. */

char *mem = NULL;

char *ptr;

long fsize;

int retval = 0;

long writestart;

long writeend;

FILE *io = NULL;

if ( !get_file_size(fname, &fsize) ) goto update_version_bailed;

if ( (mem = malloc(fsize + 1)) == NULL ) goto update_version_bailed;

if ( (io = fopen(fname, "r+")) == NULL ) goto update_version_bailed;

if ( (fread(mem, fsize, 1, io)) != 1 ) goto update_version_bailed;

mem[fsize] = '\0';

ptr = find_info_plist_version(mem);

if (ptr == NULL) goto update_version_bailed;

writestart = (long) (ptr - mem);

writeend = writestart + strlen(ptr);

ptr = mem + writeend;

if ( (fseek(io, 0, SEEK_SET) == -1) ) goto update_version_bailed;

if ( (fread(mem, fsize, 1, io)) != 1 ) goto update_version_bailed;

if ( (fseek(io, writestart, SEEK_SET) == -1) ) goto update_version_bailed;

if ( (fwrite(ver, strlen(ver), 1, io)) != 1 ) goto update_version_bailed;

if ( (fwrite(ptr, strlen(ptr), 1, io)) != 1 ) goto update_version_bailed;

for (fsize = (writeend - writestart); fsize > 0; fsize--)

if (fwrite(" ", 1, 1, io) != 1) goto update_version_bailed;

retval = 1;

update_version_bailed:

free(mem);

if (io != NULL)

fclose(io);

if (!retval) _fatal("Can't update product's installed version.");

return(retval);

} /* update_version */

int manually_locate_product(const char *name, char *buf, size_t bufsize);

int chdir_by_identifier(const char *name, const char *str,

const char *version, const char *newversion)

{

char buf[MAXPATHLEN];

Boolean b;

OSStatus rc;

int found = 0;

int hasident = ((str != NULL) && (*str));

/* if an identifier is specified, ask LaunchServices to find product... */

if (hasident)

{

CFURLRef url = NULL;

CFStringRef id = CFStringCreateWithBytes(NULL, str, strlen(str),

kCFStringEncodingISOLatin1, 0);

rc = LSFindApplicationForInfo(kLSUnknownCreator, id, NULL, NULL, &url);

CFRelease(id);

if (rc == noErr)

{

b = CFURLGetFileSystemRepresentation(url, TRUE, buf, sizeof (buf));

CFRelease(url);

if (!b)

{

_fatal("Internal error.");

return(0);

} /* if */

found = 1;

} /* if */

else

{

_log("Couldn't find product. Perhaps it isn't installed?");

} /* if */

} /* if */

if (!found) /* No identifier, or LaunchServices couldn't find it. */

{

if (!manually_locate_product(name, buf, sizeof (buf)))

{

_fatal("We can't patch the product if we can't find it!");

return(0);

} /* if */

} /* if */

_log("I think the product is installed at [%s].", buf);

if (chdir(buf) != 0)

{

_fatal("Failed to change to product's installation directory.");

return(0);

} /* if */

if (hasident)

return(parse_info_dot_plist(str, version, newversion));

return(1);

} /* chdir_by_identifier */

int show_and_install_readme(const char *fname, const char *text)

{

FILE *io;

char *cmd;

const char *envr = getenv("HOME");

if (!envr)

{

_fatal("HOME environment var not set?");

return(0);

} /* if */

cmd = alloca(strlen(fname) + strlen(envr) + 30);

strcpy(cmd, "open ");

strcat(cmd, envr);

if (cmd[strlen(cmd)-1] != '/')

strcat(cmd, "/");

strcat(cmd, "Desktop/");

strcat(cmd, fname);

io = fopen(cmd + 5, "w");

if (!io)

{

_fatal("Failed to open [%s] for writing.", cmd+5);

return(0);

} /* if */

/* !!! FIXME: error checking! */

fputs(text, io);

fclose(io);

system(cmd);

return(1);

} /* show_and_install_readme */

#endif

int calc_tmp_filenames(char **tmp1, char **tmp2)

{

static char _tmp1[MAXPATHLEN];

static char _tmp2[MAXPATHLEN];

pid_t pid = getpid();

snprintf(_tmp1, sizeof (_tmp1), "/tmp/mojopatch.tmp1.%d", (int) pid);

snprintf(_tmp2, sizeof (_tmp2), "/tmp/mojopatch.tmp2.%d", (int) pid);

*tmp1 = _tmp1;

*tmp2 = _tmp2;

return(1);

} /* calc_tmp_filenames */

static char *basedir = NULL;

static volatile int thread_alive = 0;

static void *spawn_thread(void *arg)

{

static int rc;

rc = system((char *) arg);

thread_alive = 0;

return(&rc);

} /* spawn_thread */

int spawn_xdelta(const char *cmdline)

{

pthread_t thr;

void *rc;

const char *binname = "xdelta";

char *cmd = alloca(strlen(cmdline) + strlen(basedir) + strlen(binname) + 2);

if (!cmd)

return(0);

sprintf(cmd, "\"%s%s\" %s", basedir, binname, cmdline);

thread_alive = 1;

if (pthread_create(&thr, NULL, spawn_thread, cmd) != 0)

return(0);

while (thread_alive)

{

ui_pump();

usleep(10000);

} /* while */

pthread_join(thr, &rc);

return(1); /* !!! FIXME *((int *) rc) == 0 ); */

} /* spawn_xdelta */

static void find_basedir(int *argc, char **argv)

{

const char *argv0 = argv[0];

char buf[MAXPATHLEN];

char realbuf[MAXPATHLEN];

if ((argv0 != NULL) && (strchr(argv0, '/') != NULL)) /* path specifed? */

strncpy(buf, argv0, sizeof (buf));

else

{

char *ptr;

char *envr = getenv("PATH");

if (!envr)

return;

while (*envr)

{

ptr = strchr(envr, ':');

if (!ptr)

strcpy(buf, envr);

else

{

memcpy(buf, envr, (size_t) (ptr - envr));

buf[(size_t) (ptr - envr)] = '\0';

} /* else */

envr = ptr + 1;

if (*buf == '\0')

continue;

strcat(buf, "/");

strcat(buf, argv0);

if (access(buf, X_OK) == 0)

break;

if (!ptr)

{

strcpy(buf, "."); /* oh well. */

break;

} /* if */

} /* while */

} /* else */

buf[sizeof (buf) - 1] = '\0'; /* null terminate, just in case. */

if (realpath(buf, realbuf) == NULL)

return;

char *ptr = strrchr(realbuf, '/'); /* chop off binary name. */

if (ptr != NULL)

*ptr = '\0';

if (realbuf[strlen(realbuf)-1] != '/')

strcat(realbuf, "/");

basedir = malloc(strlen(realbuf + 1));

strcpy(basedir, realbuf);

#if PLATFORM_MACOSX

/* Chop off process serial number arg that the Finder adds... */

if ( (*argc >= 2) && (strncmp(argv[1], "-psn_", 5) == 0) )

{

*argc = *argc - 1;

argv[1] = NULL;

/* Now that we know where xdelta will be, chdir out of AppBundle... */

ptr = strstr(realbuf, "/Contents/MacOS");

if (ptr != NULL)

{

*ptr = '\0';

chdir(realbuf);

} /* if */

} /* if */

#endif

} /* find_basedir */

int main(int argc, char **argv)

{

int retval;

find_basedir(&argc, argv);

retval = mojopatch_main(argc, argv);

free(basedir);

return((retval == PATCHSUCCESS) ? 0 : 1);

} /* unixmain */

/* end of platform_unix.c ... */