resin.c

解压在c盘

  g_port_count = 0;
  for (; node; node = node->next) {
    if (! strcmp(node->key, "http") ||
        ! strcmp(node->key, "srun") ||
        ! strcmp(node->key, "srun-backup") ||
        ! strcmp(node->key, "srun-backup") ||
        ! strcmp(node->key, "server")) {
      if ((! server && ! node->value) ||
          (server && node->value && ! strcmp(server, node->value))) {
        server_socket_t *ss;

        ss = bind_port(node);

        if (ss == 0) {
          fprintf(stderr, "failure opening port.\n");
          exit(1);
        }
  
        g_ports[g_port_count] = ss;

        g_port_count++;

        ss->server_index = count;
      }
      
      count++;
    }
  }
}

/**
 * If necessary, sets the user id.
 *
 * @param node top-level configuration node.
 */
static void
set_user_id(registry_t *node)
{
  char *user_name = 0;
  char *group_name = 0;
  registry_t *subnode = 0;
  struct passwd *passwd;
  struct group *group;
  int uid;
  int gid;
  
  if (node)
    node = cse_next_link(node->first, "caucho.com");

  if (node)
    subnode = cse_next_link(node->first, "http-server");

  if (node)
    user_name = cse_find_value(node->first, "user-name");
  
  if (! user_name && subnode)
    user_name = cse_find_value(subnode->first, "user-name");
  
  if (node)
    group_name = cse_find_value(node->first, "group-name");
  
  if (! group_name && subnode)
    group_name = cse_find_value(subnode->first, "group-name");

  if (! user_name)
    return;

  passwd = getpwnam(user_name);
  
  if (passwd) {
    uid = passwd->pw_uid;
    gid = passwd->pw_gid;
  }
  else {
    fprintf(stderr, "Can't change to unknown user %s\n", user_name);
    exit(1);
  }

  if (group_name) {
    group = getgrnam(group_name);
    if (group)
      gid = group->gr_gid;
  }

  if (uid >= 0) {
    if (gid >= 0) {
      setgid(gid);
      initgroups(user_name, gid);
    }

    if (setuid(uid) < 0) {
      fprintf(stderr, "Can't run as user %s(uid=%d)\n", user_name, uid);
      exit(1);
    }
  }
  
  fprintf(stderr, "Running as %s(uid=%d)\n", user_name, uid);
}

/**
 * Creates a new JniServer object
 *
 * @param env the JVM environment
 * @param argc the command-line argc
 * @param argv the comment-line argv
 *
 * @return the JniServer handle
 */
/*
static jobject
create_server(JNIEnv *env, char **argv)
{
  jobject server_obj = 0;
  jarray java_args;
  jclass string_class;
  int i;
  int argc;

  for (argc = 0; argv[argc]; argc++) {
  }

  string_class = (*env)->FindClass(env, "java/lang/String");
  
  java_args = (*env)->NewObjectArray(env, argc, string_class, 0);
  for (i = 0; i < argc; i++) {
    jstring arg = (*env)->NewStringUTF(env, argv[i]);
    
    (*env)->SetObjectArrayElement(env, java_args, i, arg);
  }
  
  server_obj = (*env)->NewObject(env, g_java.jni_server,
                                 g_java.new_jni_server, java_args);
  if ((*env)->ExceptionOccurred(env)) {
    (*env)->ExceptionDescribe(env);
    exit(1);
  }
  server_obj = (*env)->NewGlobalRef(env, server_obj);

  return server_obj;
}
*/

static int
resin_get_server_socket(resin_t *resin)
{
  if (resin->count < g_port_count)
    return (int) g_ports[resin->count++];
  else
    return 0;
}

/**
 * Forks the server for the background server.
 */
static void
fork_server(int argc, char **argv)
{
  char *pid = "resin.pid";
  char pid_file[1024];
  int pipes[2];
  FILE *file;
  int child_pid;
  struct stat st;
  int status;
  char **new_argv;
  int i, j;
  int has_stdout;
  int has_stderr;

  if (g_options.pid)
    pid = g_options.pid;

  if (pid[0] == '/')
    sprintf(pid_file, "%s", pid);
  else
    sprintf(pid_file, "%s/%s", g_options.server_root, pid);

  if (! stat(pid_file, &st)) {
    file = fopen(pid_file, "r");
    fscanf(file, "%d", &child_pid);
    fclose(file);

    if (kill(child_pid, 0) == 0) {
      fprintf(stderr, "server %s has already started (pid %d).\n",
              pid, child_pid);
      exit(1);
    }
  }
  
  setpgid(0, 0);

  /* become a daemon */
  if (fork()) {
    sleep(5);
    
    exit(0);
  }

  if (fork()) {
    exit(0);
  }
  
  file = fopen(pid_file, "w+");
  fprintf(file, "%d\n", getpid());
  fclose(file);

  new_argv = (char **) cse_malloc((argc + 10) * sizeof(char *));
  j = 0;

  for (i = 0; i < argc; i++) {
    /* cleanup if necessary */
    new_argv[j++] = argv[i];
  }
  
  new_argv[j] = 0;

  while (1) {
    /*
     * Pipe for the deadwait.  When the parent closes, the child
     * will automatically close (see the tail of main()).
     */
    pipe(pipes);

    child_pid = fork();

    if (! child_pid) {
      char *exe = new_argv[0];
    
      dup2(pipes[0], 0);
      if (pipes[0] != 0)
	close(pipes[0]);
      if (pipes[1] != 0)
	close(pipes[1]);

      execv(exe, new_argv);

      fprintf(stderr, "can't start %s\n", new_argv[0]);
      exit(1);
    }

    close(pipes[0]);

    wait(&status);

    close(pipes[1]);

    kill(child_pid, SIGQUIT);

    sleep(10);
  }
}

static void
stop_server()
{
  char *pid = "resin.pid";
  char pid_file[1024];
  struct stat st;
  FILE *file;
  int child_pid;

  if (g_options.pid)
    pid = g_options.pid;
  
  if (pid[0] == '/')
    sprintf(pid_file, "%s", pid);
  else
    sprintf(pid_file, "%s/%s", g_options.server_root, pid);

  if (stat(pid_file, &st)) {
    fprintf(stderr, "no server %s has been started.\n", pid);

    if (g_options.start || g_options.restart)
      return;
    
    exit(1);
  }

  file = fopen(pid_file, "r");
  fscanf(file, "%d", &child_pid);
  fclose(file);

  unlink(pid_file);

  fprintf(stderr, "shutting down client %d\n", child_pid);
  
  if (child_pid > 0)
    kill(child_pid, 15);
}

static void
open_logs()
{
  char log_path[1024];
  int fd;

  sprintf(log_path, "%s/log", g_options.server_root);
  mkdir(log_path, 0775);

  if (is_path_absolute(g_options.stdout_path))
    sprintf(log_path, "%s", g_options.stdout_path);
  else
    sprintf(log_path, "%s/%s", g_options.server_root, g_options.stdout_path);
  fd = open(log_path, O_RDWR|O_CREAT|O_APPEND, 0664);
  
  dup2(fd, 1);
  close(fd);

  if (is_path_absolute(g_options.stderr_path))
    sprintf(log_path, "%s", g_options.stderr_path);
  else
    sprintf(log_path, "%s/%s", g_options.server_root, g_options.stderr_path);
  fd = open(log_path, O_RDWR|O_CREAT|O_APPEND, 0664);
  dup2(fd, 2);
  close(fd);
}

int
main(int argc, char **argv)
{
  JavaVM *vm = 0;
  JNIEnv *env = 0;
  JavaVMInitArgs vm_args;
  JavaVMAttachArgs vm_attach_args;
  char envpath[8192];
  char jvmpath[8192];
  int res;
  config_t *config;
  char **new_argv;
  int i, j;
  resin_t *resin;
  jarray java_args;
  jclass string_class;

  memset(&g_options, 0, sizeof(g_options));
  memset(&vm_args, 0, sizeof(vm_args));
  memset(&vm_attach_args, 0, sizeof(vm_attach_args));
  
  new_argv = parse_command_line(argc, argv);
  
  find_java_home();
  find_resin_home(argv[0]);
  g_options.resin_home = normalize_path(g_options.resin_home);

  if (! g_options.server_root)
    g_options.server_root = g_options.resin_home;
  else
    g_options.server_root = normalize_path(g_options.server_root);

  if (! g_options.is_child && (g_options.stop || g_options.restart)) {
    stop_server();

    if (g_options.restart || g_options.start) {
      sleep(5);
    }
    else
      exit(0);
  }

  /*
   * First pass through needs to set the LD_LIBRARY_PATH and reexecute
   * the server.
   */
  if (! g_options.is_child) {
    char **new_argv;

    new_argv = (char **) malloc((argc + 10) * sizeof (char *));
    memcpy(new_argv, argv, argc * (sizeof (char *)));
    new_argv[argc] = "-resin-child";
    new_argv[argc + 1] = 0;

    set_library_path(g_options.java_home, g_options.resin_home,
                     g_options.jvm_type);

    if (g_options.start || g_options.restart) {
      fork_server(argc + 1, new_argv);
      exit(1);
    }
    else {
      execv(new_argv[0], new_argv);

      fprintf(stderr, "Can't start server %s.\n", argv[0]);
      exit(1);
    }
  }

  set_jvmpath(g_options.java_home, g_options.resin_home,
              g_options.jvm_type, jvmpath);

  chdir(g_options.server_root);

  setEnvVars(g_options.java_home);
  set_classpath();

  config = read_config(g_options.conf);

  g_config = config;

  for (j = 0; new_argv[j]; j++) {
  }

  /* extra length was already allocated */
  if (g_options.stdout_path) {
    new_argv[j++] = "-stdout";
    new_argv[j++] = g_options.stdout_path;
  }
  
  if (g_options.stderr_path) {
    new_argv[j++] = "-stderr";
    new_argv[j++] = g_options.stderr_path;
  }
  new_argv[j] = 0;

  fprintf(stdout, "%s\n", FULL_VERSION);

  if (g_options.verbose) {
    fprintf(stdout, "JAVA_HOME:   %s\n", g_options.java_home);
    fprintf(stdout, "RESIN_HOME:  %s\n", g_options.resin_home);
    fprintf(stdout, "SERVER_ROOT: %s\n", g_options.server_root);
    fprintf(stdout, "CLASSPATH:   %s\n", g_options.classpath);
    fprintf(stdout, "LDPATH:      %s\n", getenv("LD_LIBRARY_PATH"));

    for (i = 0; new_argv[i]; i++)
      fprintf(stdout, "arg %d:      %s\n", i, new_argv[i]);
  }

  if (config->error) {
    printf("%s\n", config->error);
    exit(1);
  }
  
  g_port_count = count_ports(config->registry, g_options.server);
  
  if (g_port_count <= 0) {
    fprintf(stderr, "No servers defined.\n");
    exit(1);
  }
  
  configure_ports(config->registry, g_options.server);

  /* XXX: now, change ownership */
  set_user_id(config->registry);

  if (g_options.start || g_options.restart) {
    if (! g_options.stdout_path)
      g_options.stdout_path = "log/stdout.log";
    if (! g_options.stderr_path)
      g_options.stderr_path = "log/stderr.log";

    open_logs();
  }

  resin = (resin_t *) cse_malloc(sizeof(resin_t));
  memset(resin, 0, sizeof(resin_t));
  resin->get_server_socket = resin_get_server_socket;

  strcpy(envpath, "-Djava.library.path=");
  strcat(envpath, getenv("LD_LIBRARY_PATH"));

  add_jvm_option("-Djava.library.path=%s", getenv("LD_LIBRARY_PATH"));
  add_jvm_option("-Dresin.home=%s", g_options.server_root);

  memset(&vm_args, 0, sizeof(vm_args));
  vm_args.version = JNI_VERSION_1_2;
  vm_args.options = g_options.options;
  vm_args.nOptions = g_options.n_options;
  vm_args.ignoreUnrecognized = 0;

  res = create_vm(&vm, (void **)&env, &vm_args, jvmpath);
  if (res < 0) {
    fprintf(stderr, "Failed to create JVM.\n");
    exit(1);
  }
  
  g_java.vm = vm;

  init_java(env);

  for (argc = 0; new_argv[argc]; argc++) {
  }

  string_class = (*env)->FindClass(env, "java/lang/String");

  java_args = (*env)->NewObjectArray(env, argc, string_class, 0);
  for (i = 0; i < argc; i++) {
    jstring arg = (*env)->NewStringUTF(env, new_argv[i]);
    
    (*env)->SetObjectArrayElement(env, java_args, i, arg);
  }
  
  (*env)->CallStaticVoidMethod(env, g_java.jni_server, g_java.main,
                               resin, java_args);
  
  if ((*env)->ExceptionOccurred(env))
    (*env)->ExceptionDescribe(env);
  
  (*vm)->DetachCurrentThread(vm);
  (*vm)->DestroyJavaVM(vm);

  return 0;
}