main(int argc, char *argv[])
{
char exe[128], uex[128];
int n;
if (argc <= 1)
return 1;
n = strlen(argv[1]);
if (n > 4 && !stricmp(argv[1]+n-4, ".exe")) {
strcpy(exe, argv[1]);
strcpy(uex, argv[1]);
uex[n-4] = '\0';
strcat(uex, ".uex");
} else {
strcpy(exe, argv[1]);
strcat(exe, ".exe");
strcpy(uex, argv[1]);
strcat(uex, ".uex");
}
if (!_access(uex, 4)) {
_unlink(exe);
rename(uex, exe);
}
_execv(argv[1], argv+1);
return 2;
}
static void StartSetup() {
pid_t pid;
char *cmd;
int argc;
char **argv;
int status;
if (MONSetupPath) {
cmd = MONSetupPath;
} else {
cmd = BIN_DIR "/monsetup";
}
argv = (char **)xmalloc(sizeof(char *) * 4);
argc = 0;
argv[argc++] = cmd;
argv[argc++] = "-dir";
argv[argc++] = Directory;
argv[argc++] = NULL;
if ((pid = fork()) > 0) {
waitpid(pid, &status, 0);
if (!WIFEXITED(status)) {
Error("monsetup failure");
}
} else if (pid == 0) {
_execv(cmd, argv);
} else {
Error("can't start monsetup");
}
xfree(argv);
}
void sil_reset(void)
{
const char *args[3] = {mp_argv[0], UDB_HW_RESET_ARG, 0};
sil_ui_will_reset();
if (gpsSocket) UDBSocket_close(gpsSocket);
if (telemetrySocket) UDBSocket_close(telemetrySocket);
if (serialSocket) UDBSocket_close(serialSocket);
_execv(mp_argv[0], args); // this version keeps VC++ happy (along with <process.h> above)
fprintf(stderr, "Failed to reset UDB %s\n", mp_argv[0]);
exit(1);
}
void sil_reset(void)
{
const char *args[3] = {mp_argv[0], UDB_HW_RESET_ARG, 0};
sil_ui_will_reset();
if (gpsSocket) UDBSocket_close(gpsSocket);
if (telemetrySocket) UDBSocket_close(telemetrySocket);
if (serialSocket) UDBSocket_close(serialSocket);
#ifdef _MSC_VER
_execv(mp_argv[0], args);
#else
execv(mp_argv[0], args);
#endif
fprintf(stderr, "Failed to reset UDB %s\n", mp_argv[0]);
exit(1);
}
/* Wrap the execv() that calls the pinentry program to include a special
* _CLIENT_PID environment variable, which contains the PID we gathered during
* accept(). Note that this is potentially racy if we have a lot of concurrent
* connections, but the worst that could happen is that we end up having a
* pinentry running on the wrong TTY/display.
*/
int execv(const char *path, char *const argv[])
{
static int (*_execv)(const char *, char *const[]) = NULL;
if (_execv == NULL)
_execv = dlsym(RTLD_NEXT, "execv");
if (last_pid != 0 &&
strncmp(path, PINENTRY_WRAPPER, sizeof(PINENTRY_WRAPPER) + 1) == 0) {
char env_var[40];
if (snprintf(env_var, 40, "_CLIENT_PID=%d", last_pid) < 0)
return -1;
if (putenv(env_var) < 0)
return -1;
}
last_pid = 0;
return _execv(path, argv);
}
static int StartProcess(Process *proc) {
pid_t pid;
char *msg, *p;
int i;
size_t size;
retry:
if ((pid = fork()) > 0) {
proc->pid = pid;
proc->state = STATE_RUN;
if (getenv("MONITOR_START_PROCESS_LOGGING") != NULL) {
size = 0;
for (i = 0; proc->argv[i] != NULL; i++) {
size += strlen(proc->argv[i]) + 1;
}
msg = malloc(size + 10);
memset(msg, 0, size + 10);
p = msg;
sprintf(p, "(%d) ", pid);
p += strlen(p);
for (i = 0; proc->argv[i] != NULL; i++) {
memcpy(p, proc->argv[i], strlen(proc->argv[i]));
p += strlen(proc->argv[i]);
memcpy(p, " ", 1);
p += 1;
}
Warning(msg);
free(msg);
}
} else if (pid == 0) {
_execv(proc->argv[0], proc->argv);
} else {
Message("can't start process");
goto retry;
}
return (pid);
}
int doDumpHeapInstance(const char *BinaryFilename) {
PipeMemoryReader Pipe = createPipeMemoryReader();
pid_t pid = _fork();
switch (pid) {
case -1:
errnoAndExit("Couldn't fork child process");
case 0: { // Child:
close(PipeMemoryReader_getParentWriteFD(&Pipe));
close(PipeMemoryReader_getParentReadFD(&Pipe));
dup2(PipeMemoryReader_getChildReadFD(&Pipe), STDIN_FILENO);
dup2(PipeMemoryReader_getChildWriteFD(&Pipe), STDOUT_FILENO);
_execv(BinaryFilename, NULL);
exit(EXIT_SUCCESS);
}
default: { // Parent
close(PipeMemoryReader_getChildReadFD(&Pipe));
close(PipeMemoryReader_getChildWriteFD(&Pipe));
SwiftReflectionContextRef RC =
swift_reflection_createReflectionContextWithDataLayout(
(void *)&Pipe, PipeMemoryReader_queryDataLayout,
PipeMemoryReader_freeBytes, PipeMemoryReader_readBytes,
PipeMemoryReader_getStringLength,
PipeMemoryReader_getSymbolAddress);
uint8_t PointerSize = PipeMemoryReader_getPointerSize((void*)&Pipe);
if (PointerSize != sizeof(uintptr_t))
errorAndExit("Child process had unexpected architecture");
#if defined(__APPLE__) && defined(__MACH__)
PipeMemoryReader_receiveImages(RC, &Pipe);
#else
PipeMemoryReader_receiveReflectionInfo(RC, &Pipe);
#endif
while (1) {
InstanceKind Kind = PipeMemoryReader_receiveInstanceKind(&Pipe);
switch (Kind) {
case Object:
printf("Reflecting an object.\n");
if (!reflectHeapObject(RC, Pipe))
return EXIT_SUCCESS;
break;
case Existential: {
static const char Name[] = MANGLING_PREFIX_STR "ypD";
swift_typeref_t AnyTR
= swift_reflection_typeRefForMangledTypeName(RC,
Name, sizeof(Name)-1);
printf("Reflecting an existential.\n");
if (!reflectExistential(RC, Pipe, AnyTR))
return EXIT_SUCCESS;
break;
}
case ErrorExistential: {
static const char ErrorName[] = MANGLING_PREFIX_STR "s5Error_pD";
swift_typeref_t ErrorTR
= swift_reflection_typeRefForMangledTypeName(RC,
ErrorName, sizeof(ErrorName)-1);
printf("Reflecting an error existential.\n");
if (!reflectExistential(RC, Pipe, ErrorTR))
return EXIT_SUCCESS;
break;
}
case Closure:
printf("Reflecting a closure.\n");
if (!reflectHeapObject(RC, Pipe))
return EXIT_SUCCESS;
break;
case None:
swift_reflection_destroyReflectionContext(RC);
printf("Done.\n");
return EXIT_SUCCESS;
}
}
}
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
sc_context_t *ctx = NULL;
sc_context_param_t ctx_param;
sc_card_t *card = NULL;
int r;
int argind = 0;
int exit_status = EXIT_SUCCESS;
/* decode options */
argind = decode_options(argc, argv);
/* connect to the card */
memset(&ctx_param, 0, sizeof(ctx_param));
ctx_param.ver = 0;
ctx_param.app_name = app_name;
r = sc_context_create(&ctx, &ctx_param);
if (r) {
util_fatal("failed to establish context: %s", sc_strerror(r));
return EXIT_FAILURE;
}
r = util_connect_card(ctx, &card, opt_reader, opt_wait, verbose);
if (r) {
util_fatal("failed to connect to card: %s", sc_strerror(r));
return EXIT_FAILURE;
}
/* check card type */
if ((card->type != SC_CARD_TYPE_OPENPGP_BASE) &&
(card->type != SC_CARD_TYPE_OPENPGP_V1) &&
(card->type != SC_CARD_TYPE_OPENPGP_V2) &&
(card->type != SC_CARD_TYPE_OPENPGP_V3) &&
(card->type != SC_CARD_TYPE_OPENPGP_GNUK)) {
util_error("card type %X: not an OpenPGP card", card->type);
exit_status = EXIT_FAILURE;
goto out;
}
/* fail on too many arguments */
if (argind > argc)
util_print_usage_and_die(app_name, options, option_help, NULL);
/* set default action */
if (!actions)
opt_userinfo = 1;
if (opt_cardinfo)
exit_status |= do_info(card, card_data);
if (opt_userinfo)
exit_status |= do_info(card, user_data);
if (opt_keyinfo)
exit_status |= do_info(card, key_data);
if (opt_verify && opt_pin) {
exit_status |= do_verify(card, verifytype, pin);
}
if (opt_dump_do) {
size_t n;
for (n = 0; n < opt_dump_do; n++) {
exit_status |= do_dump_do(card, do_dump_idx[n]);
}
}
if (opt_genkey)
exit_status |= do_genkey(card, key_id, keytype);
if (exec_program) {
char *const largv[] = {exec_program, NULL};
sc_unlock(card);
sc_disconnect_card(card);
sc_release_context(ctx);
#ifndef _WIN32
execv(exec_program, largv);
#else
_execv(exec_program, (const char * const*)largv);
#endif
/* we should not get here */
perror("execv()");
exit(EXIT_FAILURE);
}
if (opt_delkey)
exit_status |= do_delete_key(card, key_id);
if (opt_erase)
exit_status |= do_erase(card);
out:
sc_unlock(card);
sc_disconnect_card(card);
sc_release_context(ctx);
exit(exit_status);
}
int doDumpHeapInstance(const char *BinaryFilename) {
PipeMemoryReader Pipe = createPipeMemoryReader();
pid_t pid = _fork();
switch (pid) {
case -1:
errorAndExit("Couldn't fork child process");
exit(EXIT_FAILURE);
case 0: { // Child:
close(PipeMemoryReader_getParentWriteFD(&Pipe));
close(PipeMemoryReader_getParentReadFD(&Pipe));
dup2(PipeMemoryReader_getChildReadFD(&Pipe), STDIN_FILENO);
dup2(PipeMemoryReader_getChildWriteFD(&Pipe), STDOUT_FILENO);
_execv(BinaryFilename, NULL);
exit(EXIT_SUCCESS);
}
default: { // Parent
close(PipeMemoryReader_getChildReadFD(&Pipe));
close(PipeMemoryReader_getChildWriteFD(&Pipe));
SwiftReflectionContextRef RC = swift_reflection_createReflectionContext(
(void*)&Pipe,
PipeMemoryReader_getPointerSize,
PipeMemoryReader_getSizeSize,
PipeMemoryReader_readBytes,
PipeMemoryReader_getStringLength,
PipeMemoryReader_getSymbolAddress);
uint8_t PointerSize = PipeMemoryReader_getPointerSize((void*)&Pipe);
if (PointerSize != sizeof(uintptr_t))
errorAndExit("Child process had unexpected architecture");
PipeMemoryReader_receiveReflectionInfo(RC, &Pipe);
while (1) {
InstanceKind Kind = PipeMemoryReader_receiveInstanceKind(&Pipe);
switch (Kind) {
case Object:
printf("Reflecting an object.\n");
if (!reflectHeapObject(RC, Pipe))
return EXIT_SUCCESS;
break;
case Existential: {
swift_typeref_t AnyTR
= swift_reflection_typeRefForMangledTypeName(RC, "_TtP_", 5);
printf("Reflecting an existential.\n");
if (!reflectExistential(RC, Pipe, AnyTR))
return EXIT_SUCCESS;
break;
}
case ErrorExistential: {
swift_typeref_t ErrorTR
= swift_reflection_typeRefForMangledTypeName(RC,
"_TtPs5Error_", 21);
printf("Reflecting an error existential.\n");
if (!reflectExistential(RC, Pipe, ErrorTR))
return EXIT_SUCCESS;
break;
}
case Closure:
printf("Reflecting a closure.\n");
if (!reflectHeapObject(RC, Pipe))
return EXIT_SUCCESS;
break;
case None:
swift_reflection_destroyReflectionContext(RC);
printf("Done.\n");
return EXIT_SUCCESS;
}
}
}
}
return EXIT_SUCCESS;
}