resin.c

《jsp编程起步》里面的所有源代码

  path = getenv("PATH");
  if (path) {
    path = strdup(path);
    
    g_options.java_home = find_link_in_path(path, "jre/lib/rt.jar", "java");
  }

  if (! g_options.java_home)
    g_options.java_home = "/usr/java";
}

/**
 * Finds the value of resin_home
 *
 * 1) command-line
 * 2) getenv("RESIN_HOME")
 * 3) trying /usr/local/resin
 */
static void
find_resin_home(char *cmd)
{
  char *resin_home;
  char *path;
  
  if (g_options.resin_home) {
    return;
  }

  if ((resin_home = getenv("RESIN_HOME"))) {
    g_options.resin_home = strdup(resin_home);
    return;
  }

  g_options.resin_home = unwind_link(cmd, "lib/dom.jar");
  if (g_options.resin_home)
    return;

  if (! g_options.resin_home) {
    char buf[8192];
    getcwd(buf, sizeof(buf));

    g_options.resin_home = strdup(buf);
  }
}

/**
 * Convert a possibly relative path to an absolute path.
 */
static char *
normalize_path(char *path)
{
  char buf[8192];

  if (path[0] == '/')
    return path;

  getcwd(buf, sizeof(buf));
  strcat(buf, "/");
  strcat(buf, path);

  return strdup(buf);
}

static void
init_java(JNIEnv *env)
{
  jclass classID;
  jmethodID methodID;
  jfieldID fieldID;
  
  jni_vfs_init(env);

  classID = (*env)->FindClass(env, "com/caucho/server/http/JniServer");
  if (classID == 0) {
    fprintf(stderr, "Class not found: com.caucho.server.http.JniServer\n");
    exit(1);
  }
  g_java.jni_server = classID;

  classID = (*env)->FindClass(env, "com/caucho/server/http/JniRequest");
  if (classID == 0) {
    fprintf(stderr, "Class not found: com.caucho.server.http.JniRequest\n");
    exit(1);
  }
  g_java.jni_request = classID;

  /* Get the application's main method */
  methodID = (*env)->GetMethodID(env, g_java.jni_server, "<init>",
                                 "([Ljava/lang/String;)V");
  if (! methodID) {
    fprintf(stderr, "Can't instantiate com.caucho.server.http.JniServer\n");
    exit(1);
  }
  g_java.new_jni_server = methodID;
  
  methodID = (*env)->GetMethodID(env, g_java.jni_server, "createRequest",
                                 "()Lcom/caucho/server/http/JniRequest;");
  if (! methodID) {
    fprintf(stderr, "Can't find createRequest");
    exit(1);
  }
  g_java.create_request = methodID;
  
  methodID = (*env)->GetMethodID(env, g_java.jni_server, "close", "()V");
  if (! methodID) {
    fprintf(stderr, "Can't find close");
    exit(1);
  }
  g_java.close = methodID;
  
  methodID = (*env)->GetMethodID(env, g_java.jni_request,
                                 "dispatch", "(IIIII)V");
  g_java.dispatch = methodID;

  fieldID = (*env)->GetFieldID(env, g_java.jni_request, "uri", "[B");
  g_java.f_uri = fieldID;
  
  fieldID = (*env)->GetFieldID(env, g_java.jni_request, "uriLength", "I");
  g_java.f_uri_length = fieldID;
  
  fieldID = (*env)->GetFieldID(env, g_java.jni_request, "headerBuffer", "[C");
  g_java.f_header_buffer = fieldID;
  
  fieldID = (*env)->GetFieldID(env, g_java.jni_request, "headerOffsets", "[I");
  g_java.f_header_offsets = fieldID;
  
  fieldID = (*env)->GetFieldID(env, g_java.jni_request, "headerSize", "I");
  g_java.f_header_size = fieldID;
}

config_t *
read_config(char *name)
{
  char config_file[8192];
  FILE *file;
  config_t *config = malloc(sizeof(config_t));
  
  memset(config, 0, sizeof(config_t));

  config->p = cse_create_pool();
  config->resin_home = g_options.resin_home;

  if (! name)
    name = "conf/resin.conf";

  file = fopen(name, "r");
  if (! file) {
    fprintf(stderr, "can't find config file %s\n", name);
    exit(1);
  }

  config->registry = cse_parse(file, config, name);

  fclose(file);

  return config;
}

static int
bind_port(registry_t *node)
{
  char *value;
  char *host;
  int port;
  int ss;

  if (node)
    node = cse_next_link(node->first, "caucho.com");
  if (node)
    node = cse_next_link(node->first, "http-server");
  if (node)
    node = cse_next_link(node->first, "http");

  if (! node) {
    fprintf(stderr, "no <http> server entries defined.\n");
    exit(1);
  }

  host = cse_find_value(node->first, "host");
  if (! host)
    host = "*";
  
  value = cse_find_value(node->first, "port");
  if (value)
    port = atoi(value);
  else
    port = 8080;
  
  ss = cse_bind(host, port);
  if (ss < 0) {
    fprintf(stderr,
            "Can't bind to port %s:%d.  Check for conflicting servers\n",
            host, port);
    exit(1);
  }

  fprintf(stdout, "http listening to %s:%d\n", host, port);

  return ss;
}

/**
 * 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;
  struct passwd *passwd;
  struct group *group;
  int uid;
  int gid;
  
  if (node)
    node = cse_next_link(node->first, "caucho.com");

  if (node)
    user_name = cse_find_value(node->first, "user-name");
  if (node)
    group_name = cse_find_value(node->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);

    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);
}

static jobject
create_server(JNIEnv *env, int argc, char **argv)
{
  jobject server_obj = 0;
  jarray java_args;
  jclass string_class;
  int i;

  argc--;
  argv++;

  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 void
fork_server(char **argv)
{
  char *pid = "resin";
  char pid_file[1024];
  int fd;
  int pipes[2];
  FILE *file;
  int child_pid;
  struct stat st;
    int status;


  if (g_options.pid)
    pid = g_options.pid;
  
  sprintf(pid_file, "%s/%s.pid", g_options.resin_home, pid);

  if (! stat(pid_file, &st)) {
    fprintf(stderr, "server %s.pid has already started.\n", pid);
    exit(1);
  }

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

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

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

    child_pid = fork();

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

      argv[0] = "resin-child";
    
      execv(exe, argv);

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

    close(pipes[0]);

    wait(&status);

    kill(child_pid, SIGQUIT);
  }
}

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

  if (g_options.pid)
    pid = g_options.pid;
  
  sprintf(pid_file, "%s/%s.pid", g_options.resin_home, pid);

  if (stat(pid_file, &st)) {
    fprintf(stderr, "no server %s.pid has been started.\n", pid);
    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);

  exit(0);
}

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

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

  sprintf(log_path, "%s/log/stdout.log", g_options.resin_home);
  fd = open(log_path, O_CREAT|O_APPEND, 0664);
  dup2(fd, 1);
  close(fd);

  sprintf(log_path, "%s/log/stderr.log", g_options.resin_home);
  fd = open(log_path, O_CREAT|O_APPEND, 0664);
  dup2(fd, 2);
  close(fd);
}

int
main(int argc, char **argv)
{
  int ss;

  JavaVM *vm = 0;
  JNIEnv *env = 0;
  JavaVMInitArgs vm_args;
  jobject server_obj = 0;
  char envpath[8192];
  char buf[16];
  int len;
  int res;
  config_t *config;
  server_t *server;

  memset(&g_options, 0, sizeof(g_options));
  memset(&vm_args, 0, sizeof(vm_args));
  
  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.stop) {
    stop_server();
  }

  /*
   * First pass through needs to set the LD_LIBRARY_PATH and reexecute
   * the server.
   */
  if (! getenv("RESIN_STARTED")) {
    putenv("RESIN_STARTED=true");

    set_library_path(g_options.java_home, g_options.resin_home);

    if (g_options.start) {
      fork_server(argv);
      exit(1);
    }
    else {
      execv(argv[0], argv);

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

  chdir(g_options.resin_home);

  setEnvVars(g_options.java_home);
  set_classpath();

  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, "CLASSPATH %s\n", g_options.classpath);
    fprintf(stdout, "LDPATH %s\n", getenv("LD_LIBRARY_PATH"));
  }

  config = read_config(g_options.conf);

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

  ss = bind_port(config->registry);

  /* XXX: now, change ownership */
  set_user_id(config->registry);
  
  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.resin_home);

  vm_args.version = JNI_VERSION_1_2;
  vm_args.options = g_options.options;
  vm_args.nOptions = g_options.n_options;
  vm_args.ignoreUnrecognized = 0;

  if (g_options.start)
    open_logs();

  res = create_vm(&vm, (void **)&env, &vm_args);

  g_java.vm = vm;

  init_java(env);

  server_obj = create_server(env, argc, argv);

  server = start_server(ss, env, server_obj);

  do {
    len = read(0, buf, 1);
  } while (len > 0 || len < 0 && errno == EINTR);

  close_server(server);
  
  (*env)->CallVoidMethod(env, server_obj, g_java.close);

  /* request_run(server); */

  return 0;
}