jni_vfs.c

resinweb服务器源文件

/*
 * Copyright (c) 1998-2002 Caucho Technology -- all rights reserved
 *
 * Caucho Technology permits modification and use of this file in
 * source and binary form ("the Software") subject to the Caucho
 * Developer Source License 1.1 ("the License") which accompanies
 * this file.  The License is also available at
 *   http://www.caucho.com/download/cdsl1-1.xtp
 *
 * In addition to the terms of the License, the following conditions
 * must be met:
 *
 * 1. Each copy or derived work of the Software must preserve the copyright
 *    notice and this notice unmodified.
 *
 * 2. Each copy of the Software in source or binary form must include 
 *    an unmodified copy of the License in a plain ASCII text file named
 *    LICENSE.
 *
 * 3. Caucho reserves all rights to its names, trademarks and logos.
 *    In particular, the names "Resin" and "Caucho" are trademarks of
 *    Caucho and may not be used to endorse products derived from
 *    this software.  "Resin" and "Caucho" may not appear in the names
 *    of products derived from this software.
 *
 * This Software is provided "AS IS," without a warranty of any kind. 
 * ALL EXPRESS OR IMPLIED REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
 *
 * CAUCHO TECHNOLOGY AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE OR ANY THIRD PARTY AS A RESULT OF USING OR
 * DISTRIBUTING SOFTWARE. IN NO EVENT WILL CAUCHO OR ITS LICENSORS BE LIABLE
 * FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL,
 * CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND
 * REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR
 * INABILITY TO USE SOFTWARE, EVEN IF HE HAS BEEN ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGES.      
 *
 * @author Scott Ferguson
 */


#ifdef WIN32
#ifndef _WINSOCKAPI_ 
#define _WINSOCKAPI_
#endif 
#include <windows.h>
#include <winsock2.h> 
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <sys/time.h>
#include <pwd.h>
#endif

#ifdef linux
#include <linux/version.h>
#endif

#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
/* probably system-dependent */
#include <jni.h>

#include "../common/cse.h"
#include "resin.h"
#include "resin_jni.h"

void
cse_log(char *fmt, ...)
{
#ifdef DEBUG  
  va_list list;

  va_start(list, fmt);
  vfprintf(stderr, fmt, list);
  va_end(list);
#endif
}

int
Java_com_caucho_vfs_JniStream_readNative(JNIEnv *env,
                                         jobject obj,
                                         jint fd,
                                         jbyteArray buf,
                                         jint offset,
                                         jint length)
{
  connection_t *conn = (connection_t *) fd;
  int sublen;
  char *jbuf;
  jboolean is_copy = 0;
  char buffer[8192];

  if (! conn || conn->fd < 0)
    return -1;

  if (length < 8192)
    sublen = length;
  else
    sublen = 8192;

  sublen = conn->ops->read(conn, buffer, sublen);

  /* Should probably have a different response for EINTR */
  if (sublen < 0)
    return sublen;

  jbuf = (*env)->GetPrimitiveArrayCritical(env, buf, &is_copy);

  if (jbuf)
    memcpy(jbuf + offset, buffer, sublen);
  
  (*env)->ReleasePrimitiveArrayCritical(env, buf, jbuf, 0);

  return sublen;
}

int
Java_com_caucho_vfs_JniStream_writeNative(JNIEnv *env,
                                          jobject obj,
                                          jint fd,
                                          jbyteArray buf,
                                          jint offset,
                                          jint length)
{
  connection_t *conn = (connection_t *) fd;
  char *cbuf;
  char buffer[8192];
  jboolean is_copy;
  int sublen;
  int buffer_offset;

  buffer_offset = 0;
  
  while (conn && length > 0 && conn) {
    if (length < 8192)
      sublen = length;
    else
      sublen = 8192;

    is_copy = 0;
    cbuf = (*env)->GetPrimitiveArrayCritical(env, buf, &is_copy);

    if (cbuf)
      memcpy(buffer, cbuf + offset, sublen);

    (*env)->ReleasePrimitiveArrayCritical(env, buf, cbuf, 0);

    if (cbuf) {
      sublen = conn->ops->write(conn, buffer, sublen);
    }
    else
      return -1;

    if (sublen < 0)
      return sublen;

    length -= sublen;
    offset += sublen;
  }

  return 0;
}

int
Java_com_caucho_vfs_JniStream_flushNative(JNIEnv *env,
                                          jobject obj,
                                          jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return -1;
  else
    return 0;

  /* return cse_flush_request(res); */
}

void
Java_com_caucho_vfs_JniStream_closeNative(JNIEnv *env,
                                          jobject obj,
                                          jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (conn) {
    conn->ops->close(conn);
  }
}

void
Java_com_caucho_vfs_QJniSocket_closeNative(JNIEnv *env,
                                          jobject obj,
                                          jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (conn) {
    conn->ops->close(conn);
    conn->ops->free(conn);
  }
}

jboolean
Java_com_caucho_vfs_QJniSocket_isSecure(JNIEnv *env,
                                        jobject obj,
                                        jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return 0;
  
  return conn->ssl_cipher != 0;
}

jstring
Java_com_caucho_vfs_QJniSocket_getCipher(JNIEnv *env,
                                         jobject obj,
                                         jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn || ! conn->ssl_cipher)
    return 0;

  return (*env)->NewStringUTF(env, conn->ssl_cipher);
}

jint
Java_com_caucho_vfs_QJniSocket_getCipherBits(JNIEnv *env,
                                         jobject obj,
                                         jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return 0;
  else
    return conn->ssl_bits;
}

void
Java_com_caucho_vfs_QJniSocket_setTimeout(JNIEnv *env,
                                          jobject obj,
                                          jint fd,
                                          jint timeout)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return;

  conn->timeout = timeout;
}

jint
Java_com_caucho_vfs_QJniServerSocket_acceptNative(JNIEnv *env,
                                                  jobject obj,
                                                  jint ss)
{
  server_socket_t *socket = (server_socket_t *) ss;
  connection_t *conn;

  if (! socket)
    return 0;

  conn = socket->accept(socket);

  return (int) conn;
}

jint
Java_com_caucho_vfs_QJniServerSocket_getLocalPort(JNIEnv *env,
                                                  jobject obj,
                                                  jint ss)
{
  server_socket_t *socket = (server_socket_t *) ss;

  if (! socket)
    return 0;
  else
    return socket->port;
}

jint
Java_com_caucho_server_http_JniServer_getServerSocket(JNIEnv *env,
                                                      jobject obj,
                                                      jint resin_fd)
{
  resin_t *resin = (resin_t *) resin_fd;
  int ss;

  if (! resin)
    return -1;

  ss = resin->get_server_socket(resin);
  
  return ss;
}

jlong
Java_com_caucho_vfs_QJniSocket_getRemoteIP(JNIEnv *env,
                                           jobject obj,
                                           jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return 0;

  return ntohl(conn->client_sin.sin_addr.s_addr);
}

jint
Java_com_caucho_vfs_QJniSocket_getRemotePort(JNIEnv *env,
                                             jobject obj,
                                             jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return 0;

  return ntohs(conn->client_sin.sin_port);
}

jlong
Java_com_caucho_vfs_QJniSocket_getLocalIP(JNIEnv *env,
                                           jobject obj,
                                           jint fd)
{
  connection_t *conn = (connection_t *) fd;

  if (! conn)
    return 0;

  return ntohl(conn->server_sin.sin_addr.s_addr);
}

jint
Java_com_caucho_vfs_QJniSocket_getLocalPort(JNIEnv *env,
                                             jobject obj,
                                             jint fd)