initlibx ml par

author: buraq <buraq@epfl.ch> 2004-07-26 13:18:44 +0000
committer: buraq <buraq@epfl.ch> 2004-07-26 13:18:44 +0000
commit: 63f1dcdd145456457014a05e8378117bfaa292cb (patch)
tree: 83558152d9577a36160c8b66a66410d5c4f675ce /sources
parent: 9309cf418f5eefb20bfc07dcc4dcfab176c5bba4 (diff)
download: scala-63f1dcdd145456457014a05e8378117bfaa292cb.tar.gz
scala-63f1dcdd145456457014a05e8378117bfaa292cb.tar.bz2
scala-63f1dcdd145456457014a05e8378117bfaa292cb.zip
17 files changed, 884 insertions, 0 deletions
diff --git a/sources/scala/tools/servlet/ExcepServlet.scala b/sources/scala/tools/servlet/ExcepServlet.scala
new file mode 100644
index 0000000000..041942665a
--- /dev/null
+++ b/sources/scala/tools/servlet/ExcepServlet.scala
@@ -0,0 +1,23 @@
+package scala.tools.servlet;
+import java.io._;
+import scala.xml._;
+import scala.collection.mutable.HashMap ;
+
+class ExcepServlet() extends ScalaServlet{
+
+override def doGetXML(info: HashMap[String,String]): Node = {
+  val code:String= info("code");
+  val detail:String=info("detail");
+
+  <html>
+    <head>
+      <title>SERVLET ERROR</title>
+    </head>
+    <body>
+      <big>Attention,erreur dans la servlet</big>
+      <br/>type de l erreur: { code }<br/>{ detail }
+    </body>
+  </html>
+}
+
+}
diff --git a/sources/scala/tools/servlet/SERVLET.scala b/sources/scala/tools/servlet/SERVLET.scala
new file mode 100644
index 0000000000..c1ba91e829
--- /dev/null
+++ b/sources/scala/tools/servlet/SERVLET.scala
@@ -0,0 +1,29 @@
+package scala.tools.servlet;
+
+import java.io._;
+import java.util._;
+import java.net._;
+
+object SERVLET {
+
+  final val  STATUS_OKAY  = 50;
+  final val  STATUS_NOT_IMPLEMENTED= 60;
+  final val STATUS_FORBIDDEN=70;
+  final val STATUS_NOT_FOUND=80;
+  final val  STATUS_BAD_REQUEST= 90;
+  final val STATUS_INTERNAL_ERROR =99;
+
+
+
+  def getCodeMessage (code:int): String = code match {
+
+    case STATUS_OKAY =>  "OK"
+    case  STATUS_BAD_REQUEST=> "Bad Request"
+    case STATUS_FORBIDDEN =>  "Forbidden"
+    case STATUS_NOT_FOUND =>  "Not Found"
+    case STATUS_INTERNAL_ERROR =>  "Server Internal Error"
+    case STATUS_NOT_IMPLEMENTED =>  "Not Implemented"
+    case _ =>  "Unknown Code (" + code + ")"
+
+  }
+}
diff --git a/sources/scala/tools/servlet/ScalaCookiee.scala b/sources/scala/tools/servlet/ScalaCookiee.scala
new file mode 100644
index 0000000000..2a9a15adfd
--- /dev/null
+++ b/sources/scala/tools/servlet/ScalaCookiee.scala
@@ -0,0 +1,14 @@
+package scala.tools.servlet;
+
+import java.io._;
+
+class ScalaCookiee(name:String,value:String) {
+
+ def getName():String ={
+     name;
+  }
+
+  def getValue():String={
+    value;
+  }
+}
diff --git a/sources/scala/tools/servlet/ScalaServlet.scala b/sources/scala/tools/servlet/ScalaServlet.scala
new file mode 100644
index 0000000000..f3aabd9bf9
--- /dev/null
+++ b/sources/scala/tools/servlet/ScalaServlet.scala
@@ -0,0 +1,59 @@
+package scala.tools.servlet;
+
+import java.io.IOException;
+import scala.xml._;
+import scala.collection.mutable.HashMap ;
+import http.HttpOutputStream;
+// import scala.collection.mutable.HashMap
+// val x = new HashMap[String,String]
+// x.update("key","value");
+// x.get("key") match {
+//   case Some( value ) => ...
+//   case None          => ...
+// } x("key")
+
+abstract class ScalaServlet {
+  var output:HttpOutputStream = null;
+  // HashMap[String,String]
+  def doGetXML(info: HashMap[String,String]): scala.xml.Node ;
+
+  final def doGet(out: HttpOutputStream, info: HashMap[String,String]): Unit= {
+    try{
+      out.write( doGetXML( info ).toString() );
+    }
+    catch {
+      case sException:ServletException => ReturnException( sException.returnType(),sException.returnInfo());
+      case ex:Exception => ReturnException(30,"");
+    }
+  }
+
+  final def ReturnException(code:int, detail :String):unit={
+    var info = new HashMap[String,String];
+    info.update("code", SERVLET.getCodeMessage(code) );
+    info.update("detail", detail);
+    new ExcepServlet().doGet(output, info);
+    return null;
+
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sources/scala/tools/servlet/ServletException.scala b/sources/scala/tools/servlet/ServletException.scala
new file mode 100644
index 0000000000..8a9ba9e032
--- /dev/null
+++ b/sources/scala/tools/servlet/ServletException.scala
@@ -0,0 +1,13 @@
+package scala.tools.servlet;
+import java.io._;
+import java.util._;
+import java.lang.Math._;
+import scala.xml._;
+class ServletException(typ:int,info:String) extends Exception{
+ def returnType():int={typ;}
+  def returnInfo():String={info;}
+
+}
+
+
+
diff --git a/sources/scala/tools/servlet/engine/Connector.scala b/sources/scala/tools/servlet/engine/Connector.scala
new file mode 100644
index 0000000000..89fd326bd5
--- /dev/null
+++ b/sources/scala/tools/servlet/engine/Connector.scala
@@ -0,0 +1,25 @@
+package scala.tools.servlet.engine;
+
+import java.net.{ Socket, ServerSocket };
+
+/** for every port, there is one connector that instantiates a handler
+ *  per client connection
+ */
+abstract class Connector(thePort: Int) extends Thread {
+  super.setDaemon(true);
+
+  /** concrete instances of Connectors must override this with a factory
+   *  for protocol handlers
+   */
+  def makeHandler(s: Socket): Thread; //Handler;
+
+  final val port          = thePort;
+  final val serverSocket  = new ServerSocket(thePort);
+
+  // @todo: handler pooling
+  final override def run() = while(true) {
+    val client = serverSocket.accept(); /* returns a socket upon connection */
+    val t = makeHandler(client);
+    t.start();
+  }
+}
diff --git a/sources/scala/tools/servlet/engine/Main.scala b/sources/scala/tools/servlet/engine/Main.scala
new file mode 100644
index 0000000000..d98fcdc432
--- /dev/null
+++ b/sources/scala/tools/servlet/engine/Main.scala
@@ -0,0 +1,25 @@
+package scala.tools.servlet.engine;
+
+import java.net.ServerSocket;
+
+/** Main loop of the servlet engine, opens a ServerSocket
+ *  and spawns a thread when accepting a client connections.
+ *
+ *  servletEngine depends on mappings
+ *  <ul>
+ *    <li>p: ports to protocol, and</li>
+ *    <li>s: url to servlet</li>
+ *  </ul>
+ */
+object Main {
+
+  //@todo make this configurable with ports and handlers
+  private var hcon: Thread = new servlet.http.HttpConnector(8000);
+  def main(args: Array[String]): Unit = {
+    Console.println("starting http connector at 8000");
+    hcon.start();
+    while(true) {
+      Thread.sleep(50000)
+    }
+  }
+}
diff --git a/sources/scala/tools/servlet/engine/Mapping.scala b/sources/scala/tools/servlet/engine/Mapping.scala
new file mode 100644
index 0000000000..c709cab686
--- /dev/null
+++ b/sources/scala/tools/servlet/engine/Mapping.scala
@@ -0,0 +1,24 @@
+package scala.tools.servlet.engine;
+
+import java.io._;
+
+class Mapping(){
+
+  val map = new File(http.HTTP.SERVER_LOCATION,http.HTTP.translateFilename("map.prop"));
+  val myProp = new java.util.Properties();
+
+  try{
+    myProp.load(new FileInputStream(map));
+  }
+
+  catch{
+    case e:FileNotFoundException  =>  System.out.println("FileNotFoundException ");
+    case e:IOException =>  System.out.println("IOException");
+    case e: IllegalArgumentException =>  System.out.println(" IllegalArgumentException");
+  }
+
+  def switch(original:String):String={
+    myProp.getProperty(original);
+  }
+
+}
diff --git a/sources/scala/tools/servlet/http/HTTP.scala b/sources/scala/tools/servlet/http/HTTP.scala
new file mode 100644
index 0000000000..3e186ea136
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HTTP.scala
@@ -0,0 +1,172 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.net._;
+import scala.collection.mutable.HashMap;
+
+/** constants */
+object HTTP {
+  val  SERVER_INFO: String= "JNP-HTTPD/1.0";
+  val  SERVLET: String= "/servlet/";
+  val  SERVER_LOCATION: File= new File(System.getProperty("user.dir"));
+  val  HTML_ROOT: File= new File(SERVER_LOCATION,"html");
+  val  PORT:Int = 80  ;
+  val  DEFAULT_INDEX: String = "index.html";
+
+  final val METHOD_GET : String="GET";
+  final val METHOD_POST : String="POST";
+  final val METHOD_HEAD : String="HEAD";
+
+
+  final val STATUS_OKAY  = 200;
+  final val STATUS_NO_CONTENT= 204;
+  final val STATUS_MOVED_PERMANENTLY= 301;
+  final val STATUS_MOVED_TEMPORARILY=302;
+  final val STATUS_BAD_REQUEST=400;
+  final val STATUS_FORBIDDEN=403;
+  final val STATUS_NOT_FOUND=404;
+  final val STATUS_NOT_ALLOWED=405;
+  final val STATUS_INTERNAL_ERROR =500;
+  final val STATUS_NOT_IMPLEMENTED=501;
+
+  def getCodeMessage (code:int): String = code match {
+
+    case STATUS_OKAY =>  "OK"
+    case STATUS_NO_CONTENT => "No Content"
+    case STATUS_MOVED_PERMANENTLY =>  "Moved Permantely"
+    case STATUS_MOVED_TEMPORARILY =>  "Moved Temporarily"
+    case STATUS_BAD_REQUEST => "Bad Request"
+    case STATUS_FORBIDDEN =>  "Forbidden"
+    case STATUS_NOT_FOUND =>  "Not Found"
+    case STATUS_NOT_ALLOWED =>  "Method Not Allowed"
+    case STATUS_INTERNAL_ERROR =>  "Server Internal Error"
+    case STATUS_NOT_IMPLEMENTED =>  "Not Implemented"
+    case _ =>  "Unknown Code (" + code + ")"
+
+  }
+
+  def canonicalizePath(path: String):String={
+    val chars:Array[char] = path.toCharArray();
+    var length:int = chars.length;
+    var idx:int =0;
+    var odx:int =0;
+
+    idx = indexOf (chars, length,'/',odx);
+    while (  idx <  (length - 1)){
+      val ndx:int = indexOf (chars, length,'/',idx + 1);
+      var  kill = -1;
+      if (ndx == idx + 1){
+	kill = 1;
+      }
+      else if((ndx >= idx + 2) && (chars(idx + 1 )=='.')){
+	if(ndx == idx + 2){
+          kill = 2;
+        } else if ((ndx == idx +3) && (chars(idx + 2) == '.')){
+
+          kill = 3;
+          while ((idx > 0) && (chars({idx = idx -1; idx}) !='/'))
+          kill = kill +1;
+
+        }}
+      if (kill == -1){
+        odx = ndx;
+      } else if (idx +kill >= length){
+        odx = idx +1;
+	length =odx ;
+      } else {
+        length =length- kill;
+        System.arraycopy(chars,idx +1+kill, chars,idx +1,length-idx-1);
+
+        odx =idx;
+      }
+      idx = indexOf (chars, length,'/',odx);
+    }
+
+    return new String (chars, 0, length);
+  }
+
+
+  def indexOf (chars: Array[char],length:int,chr: char,from:int):int={
+    var frome :int = from;
+    while ((frome < length) && (chars(frome) != chr))
+    frome=frome + 1;
+    return frome
+  }
+
+
+  def translateFilename (filename:String ):String ={
+    val result:StringBuffer  = new StringBuffer ();
+    try {
+      var idx = 0;
+      var  odx = 0;
+      idx = filename.indexOf ('/',odx);
+      while (idx != -1){
+	result.append(filename.substring(odx,idx)).append(File.separator);
+	odx= idx +1;
+	idx = filename.indexOf ('/',odx);
+      }
+      result.append(filename.substring(odx));}
+    catch{
+      case e :java.lang.NullPointerException => System.out.println("attention erreur");
+    }
+
+    return result.toString();
+  }
+
+  final var mimeTypes = new HashMap[String, String]();
+
+  mimeTypes.update("gif", "image/gif");
+  mimeTypes.update("jpeg", "image/jpeg");
+  mimeTypes.update("jpg", "image/jpeg");
+  mimeTypes.update("html", "text/html");
+  mimeTypes.update("htm" , "text/html");
+
+  def guessMimeType(fileName: String): String ={
+    val i =fileName.lastIndexOf(".");
+    val typ = mimeTypes.get(fileName.substring (i + 1).toLowerCase()).asInstanceOf[String];
+    if (typ != null) {typ} else {"text/plain"};
+
+  }
+
+
+  def processing(inf: String): HashMap[String, String]={
+    var  hashList = new HashMap[String, String];
+    var info = inf;
+    var i=occurence(info,"&");
+    info = "&".concat(info);
+    info = info.concat("&");
+    var a= "";
+    var b = "";
+    var j= 0;
+    /*
+    si info = aaaa=3&bbbb=4&cccc=5 alors on le rend comme suit: &aaaa=3&bbbb=4&cccc=5&
+    dans la boucle
+    a = aaaa
+    b= 3
+    */
+    while(j < i){
+      var idxAND=info.indexOf("&");
+      var idxEQUAL=info.indexOf("=");
+      var idxSecondAND = info.indexOf("&",idxAND+1);
+      a = info.substring(idxAND+1,idxEQUAL);
+      b = info.substring(idxEQUAL+ 1,idxSecondAND);
+      hashList.update(a, b);
+      info = info.substring(idxSecondAND);
+      j=j+1;
+    }
+    hashList;
+
+
+  }
+  def occurence(tsr:String,cr:String):int={
+    var n= 1;
+    var str = tsr;
+    var idx = str.indexOf(cr);
+    while (idx != -1){
+      n = n+1;
+      str=str.substring(idx+1);
+      idx = str.indexOf(cr);
+    }
+    n;
+  }
+}
diff --git a/sources/scala/tools/servlet/http/HttpConnector.scala b/sources/scala/tools/servlet/http/HttpConnector.scala
new file mode 100644
index 0000000000..424d43e17d
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpConnector.scala
@@ -0,0 +1,12 @@
+package scala.tools.servlet.http;
+
+import java.net.{ Socket, ServerSocket };
+
+/** for every port, there is one connector that instantiates a handler
+ *  per client connection
+ */
+class HttpConnector(port: Int) extends servlet.engine.Connector(port) {
+
+  def makeHandler(s: Socket) = new HttpHandler( s );
+
+}
diff --git a/sources/scala/tools/servlet/http/HttpException.scala b/sources/scala/tools/servlet/http/HttpException.scala
new file mode 100644
index 0000000000..9bbaf4f5ed
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpException.scala
@@ -0,0 +1,27 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+
+/**
+La classe HttpException est une sous-classe de IOException, elle retourne au client une page HTML qui contient les erreurs dont les types se trouvent dans la classe HTTP.
+
+*/
+class HttpException(code : int, detail: String) extends IOException (detail) {
+
+
+  def toProcessor = new HttpProcessor {
+
+    override  def processRequest( out : HttpOutputStream ) : unit ={
+     out.setCode(code);
+      out.setHeader("Content-Type", "text/html");
+      if(out.sendHeaders()){
+	val msg = HTTP.getCodeMessage (code);
+	out.write("<HTML><HEAD><TITLE>"+ code + " " +msg + "</TITLE></HEAD>\n"+"<BODY> <H1>" +
+		  msg +"</H1>\n"+ getMessage () + "<P>\n </BODY></HTML>\n");
+      }
+
+    }
+
+  }
+
+}
diff --git a/sources/scala/tools/servlet/http/HttpFile.scala b/sources/scala/tools/servlet/http/HttpFile.scala
new file mode 100644
index 0000000000..b2c503b642
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpFile.scala
@@ -0,0 +1,38 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.net._;
+import scala.collection.mutable.HashMap;
+
+/**
+La classe HttpFile implémente le trait HttpProcessor et permit de servir des fichiers statiques depuis le répétoire local des fichiers
+*/
+
+class HttpFile(in: HttpInputStream, info: HashMap[String, String]) with HttpProcessor{
+
+  if (in.getMethod() == HTTP.METHOD_HEAD){
+    throw new HttpException (HTTP.STATUS_NOT_ALLOWED,"<TT>" + in.getMethod ()+ " "+ in.getPath() +"</TT>");
+  }
+
+  var file = new File (HTTP.HTML_ROOT, HTTP.translateFilename(in.getPath()));
+  if(in.getPath().endsWith("/"))
+    file = new File(file, HTTP.DEFAULT_INDEX);
+  if(!file.exists())
+    throw new HttpException (HTTP.STATUS_NOT_FOUND,"le Fichier <TT>" +in.getPath() + "</TT> n'est pas trouvé");
+  if(file.isDirectory())
+    throw new HttpException (HTTP.STATUS_MOVED_PERMANENTLY,in.getPath() + "/");
+  if (!file.isFile() || !file.canRead())
+    throw new HttpException (HTTP.STATUS_FORBIDDEN,
+			     in.getPath());
+
+
+  override def processRequest(out: HttpOutputStream): Unit ={
+    out.setHeader("Content-type", HTTP.guessMimeType(file.getName()));
+    out.setHeader("Contents-length", String.valueOf(file.length()));
+    if(out.sendHeaders()) {
+      val  in = new FileInputStream(file);
+      out.write(in);
+      in.close();
+    }
+  }
+}
diff --git a/sources/scala/tools/servlet/http/HttpHandler.scala b/sources/scala/tools/servlet/http/HttpHandler.scala
new file mode 100644
index 0000000000..b8d78ab487
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpHandler.scala
@@ -0,0 +1,83 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.net._;
+import scala.collection.mutable.HashMap;
+
+class HttpHandler(client: Socket) extends Thread {
+
+  override def run(): Unit  ={
+
+    try {
+      val httpIn  = new HttpInputStream (client.getInputStream());
+      var httpOut = new HttpOutputStream(client.getOutputStream(), httpIn);
+      val processor= getProcessor(httpIn);
+      processor.processRequest(httpOut);
+      httpOut.flush();
+    }
+
+    catch {
+      case e:IOException => e.printStackTrace();
+    }
+
+    try {
+      client.close ();
+    }
+
+    catch {
+      case e: IOException => e.printStackTrace();
+    }
+
+  }
+
+
+    /* La methode run: on a construit premierement un HttpInputStream dans le
+  client  Input Stream, ceci nous facilte lire et parser les requetes HTTP*/
+
+  def getProcessor(httpIn: HttpInputStream): HttpProcessor={
+    var value = 0;
+    var infoString = " " ;
+    var info:HashMap[String, String] = null;
+    var error: HttpProcessor=null;
+    var srv:HttpServletPro=null;
+    var fil:HttpFile=null;
+
+    try{
+      httpIn.readRequest ();
+      var index = httpIn.getInitialRequest().indexOf("?");
+      if(index != -1){
+	infoString = httpIn.getInitialRequest().substring(index+1);
+	info = HTTP.processing(infoString);
+      }
+
+      if (httpIn.getPath().startsWith(HTTP.SERVLET)){
+	value = 1;
+	srv = new HttpServletPro(httpIn, info);
+      }
+      else{
+	value = 2;
+	fil = new HttpFile(httpIn, info);
+      }
+    }
+
+    catch {
+      case e: HttpException => {
+	error=e.toProcessor;
+	value=3;
+      }
+      case ex: Exception => {
+	val trace = new StringWriter ();
+	ex.printStackTrace(new PrintWriter (trace,true));
+	val exept =  new HttpException(HTTP.STATUS_INTERNAL_ERROR,"<PRE>"+ trace +"</PRE>");
+	value=3;
+	error= exept.toProcessor;}
+    }
+
+    if(value == 1)
+      return srv ;
+    else if(value == 2)
+      return  fil;
+    else
+      return error;
+}
+}
diff --git a/sources/scala/tools/servlet/http/HttpInputStream.scala b/sources/scala/tools/servlet/http/HttpInputStream.scala
new file mode 100644
index 0000000000..49956c1d15
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpInputStream.scala
@@ -0,0 +1,145 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.net._;
+import java.lang._;
+import scala.collection.mutable.HashMap;
+import java.util.{ NoSuchElementException, StringTokenizer };
+/**
+La classe HttpInputStream fournit un support specialisé pour lire les requêtes HTTP
+*/
+class HttpInputStream(in: InputStream) extends BufferedInputStream(in) {
+  var method = "GET" ;
+  var queryString = "initialisation" ;
+  var path= "index.html";
+  var initialRequest =" ";
+  var version: double = 0;
+  val headers: HashMap[String, String] = new HashMap[String, String]();
+
+  def readRequest(): Unit = {
+    //System.out.println((HTTP.SERVER_LOCATION));
+    val request: String = readLine();
+    if (request == null)
+      throw new HttpException (HTTP.STATUS_BAD_REQUEST,"Null query");
+    val parts = new StringTokenizer(request);
+
+    try{
+      // ici on va parcourir la requete en cherchant les informations requises
+      if (parts.hasMoreTokens ())
+	parseMethod (parts.nextToken());
+      if (parts.hasMoreTokens ()){
+	initialRequest = parts.nextToken();
+	parseRequest (initialRequest);
+      }
+    }
+
+    catch{
+      case ex:NoSuchElementException => throw new HttpException(HTTP.STATUS_BAD_REQUEST, request);
+    }
+
+    if (parts.hasMoreTokens ())
+      parseVersion (parts.nextToken ());
+    else
+      version= 0.9;
+    if((version >= 1.0)&&(method == HTTP.METHOD_HEAD))
+      throw new HttpException (HTTP.STATUS_NOT_ALLOWED, method);
+    if(version >= 1.0)
+      readHeaders();
+
+    }
+
+
+  // on recupere grace à cette methode la methode (get, header ou post)demandé
+  def  parseMethod(method: String ): Unit= method.match {
+    case HTTP.METHOD_GET
+         | HTTP.METHOD_HEAD
+         | HTTP.METHOD_POST => this.method = method;
+    case _ =>
+      throw new HttpException (HTTP.STATUS_NOT_IMPLEMENTED, method);
+  }
+
+  /// on recupere grace à cette methode le URI demandé
+  def parseRequest(request: String): Unit ={
+    if(!request.startsWith("/"))
+      throw new HttpException (HTTP.STATUS_BAD_REQUEST,request);
+    val queryIdx  = request.indexOf('?');
+    if (queryIdx == -1){
+      path = HTTP.canonicalizePath(request);
+      queryString ="";
+    }
+    else{
+      path = HTTP.canonicalizePath (request.substring(0, queryIdx));
+      queryString = request.substring(queryIdx + 1);
+      }
+  }
+
+  //la methode suivante parse la version
+  def parseVersion(verStr: String) : unit ={
+    if(!verStr.startsWith("HTTP/"))
+      throw new HttpException (HTTP.STATUS_BAD_REQUEST,verStr);
+
+    try{
+      version = Float.valueOf (verStr.substring(5)).floatValue ();}
+
+    catch {
+      case e:NumberFormatException => throw new HttpException(HTTP.STATUS_BAD_REQUEST, verStr);
+      case defaul:Exception => System.out.println("sdfew");}
+  }
+
+  //// la methode suivante lit les headers des requetes,on les lit jusqu a ce qu
+  //// on trouve une ligne vide
+  def readHeaders (): unit ={
+    var header = readLine ();
+    while ((header !=null) &&  !header.equals("")){
+      val colonIdx:int = header.indexOf(':');
+      if (colonIdx != -1){
+	val name = header.substring(0, colonIdx);
+	val value = header.substring(colonIdx + 1);
+	val _ = headers.update(name.toLowerCase(), value.trim());
+      }
+      header = readLine ();
+    }
+  }
+
+  def readLine (): String = {
+    val line = new StringBuffer();
+    var c = read();
+    if(c == -1)
+      return "error";
+    while ((c != -1)&&(c != '\n')&&(c != '\r')){
+      line.append( c.asInstanceOf[char] );
+      c = read();
+    }
+    if (c == '\r')
+      pos = pos - 1;
+    return line.toString();
+  }
+
+  def getMethod () : String ={
+    return method;
+  }
+
+  def getPath (): String ={
+    return path;
+  }
+
+  def getQueryString (): String ={
+    return queryString;}
+
+  def getVersion(): double ={
+    return version;}
+
+  def getHeader(name:String): String ={
+    return headers(name.toLowerCase());
+  }
+
+  def getHeaderNames(): Iterator[String] ={
+    return headers.keys;
+  }
+
+  def getInitialRequest (): String ={
+    return initialRequest;
+  }
+
+}
+
diff --git a/sources/scala/tools/servlet/http/HttpOutputStream.scala b/sources/scala/tools/servlet/http/HttpOutputStream.scala
new file mode 100644
index 0000000000..cc3acda81c
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpOutputStream.scala
@@ -0,0 +1,102 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.lang._;
+import java.util._;
+import scala.Symbol;
+import scala.xml._;
+/**
+La classe HttpOutputStream fournit un support spécialisé pour écrire les reponses aux requêtes HTTP
+*/
+class HttpOutputStream(out:OutputStream , in: HttpInputStream ) extends  BufferedOutputStream(out){
+  var code: int = 0;
+  var sendHeaders1 :  boolean=true;
+  var sendBody:  boolean= true;
+  var headers:  Hashtable  = new Hashtable ();
+  var cookieEnable:boolean = false;
+  var currentCookie:ScalaCookiee = _  ;
+
+  code = HTTP.STATUS_OKAY;
+  setHeader ("server", HTTP.SERVER_INFO);
+  setHeader("Date", new Date ().toString());
+  sendHeaders1 = (in.getVersion() >= 1.0);
+  sendBody = !HTTP.METHOD_HEAD.equals (in.getMethod());
+
+  def setCode ( code:int):unit={
+    this.code=code;
+  }
+
+  def setHeader (attr:String , value:String ) :unit ={
+    /*
+    put(Object key, Object value)
+    fait correspondre la clé specifié à la valeur specifié dans la hashtable
+    */
+    headers.put(attr, value);
+    val i =0;
+  }
+
+
+  def sendHeaders() : boolean={
+    if(sendHeaders1) {
+      write ("HTTP/1.0" +code + " " + HTTP.getCodeMessage(code)+ "\r\n");
+      /* la mehode keys() Retourne une enumeration des clés de cette table de
+      hashage */
+      write("Date: "+headers.get("Date"));
+      headers.remove("Date");
+      if(cookieEnable){
+	write("\nSet-Cookie:"+currentCookie.getName()+"="+currentCookie.getValue()+"\n");
+      }
+      val attrs = headers.keys ();/*return Enumeration type*/
+      while (attrs.hasMoreElements()){
+	val attr = attrs.nextElement().asInstanceOf[String];
+	write (attr + ":" + headers.get(attr) + "\r\n");
+      }
+      write ("\n");
+    }
+    return sendBody;
+  }
+
+
+  def write (msg: String ): unit ={
+    var b:Array[byte] = msg.getBytes("latin1");
+    write (b,0,b.length);
+  }
+
+  override def write(bytes:Array[scala.Byte],offs:int,len:int):unit = {
+    super.write (bytes,offs,len);
+  }
+
+
+  override def write(i:int):unit ={
+  }
+
+
+  def write (in: InputStream ):unit={
+    //buf le buffer interne dans lequel les données sont enregistrées
+    var n = buf.length;
+    var length = buf.length;
+    n = in.read(buf, count, length - count);
+    while (n >= 0){
+      count = count + n;
+      if (count >= length){
+	count =0;
+	out.write(buf,count,length);
+      }
+      n = in.read(buf, count, length - count);
+
+    }
+  }
+
+
+  def setCookie(c : ScalaCookiee):unit={
+    cookieEnable= true;
+    currentCookie = c;
+  }
+
+
+  def disableCookie():unit={
+    cookieEnable= false;
+    currentCookie = null;
+  }
+
+}
diff --git a/sources/scala/tools/servlet/http/HttpProcessor.scala b/sources/scala/tools/servlet/http/HttpProcessor.scala
new file mode 100644
index 0000000000..41a79f3e23
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpProcessor.scala
@@ -0,0 +1,9 @@
+package scala.tools.servlet.http ;
+
+import java.io._;
+/**
+le processing actuel de la requête du client est reporté aux classes qui implemetent le trait HttpProcessor, ce trait decrit la façon avec laquelle la classe Httpd peut appeler le processeur pour repondre à la requête du client.
+*/
+ trait HttpProcessor {
+   def processRequest(out: HttpOutputStream): Unit ={};
+}
diff --git a/sources/scala/tools/servlet/http/HttpServletPro.scala b/sources/scala/tools/servlet/http/HttpServletPro.scala
new file mode 100644
index 0000000000..526b265644
--- /dev/null
+++ b/sources/scala/tools/servlet/http/HttpServletPro.scala
@@ -0,0 +1,84 @@
+package scala.tools.servlet.http;
+
+import java.io._;
+import java.net._;
+import scala.collection.mutable.HashMap;
+
+
+class HttpServletPro(in: HttpInputStream, info: HashMap[String,String]) with HttpProcessor{
+
+  var servletName="" ;
+  val servletInfo ="";
+  var servlet = new File (HTTP.SERVER_LOCATION,HTTP.translateFilename("src"));
+  val  contentLength = 0;
+  //val repertoire = extract();
+
+  var servletClassName:String = extract();
+
+  /*
+  if(!servlet.exists()){
+    throw new HttpException (HTTP.STATUS_NOT_FOUND, "la servlet <TT>"+ servletName + "</TT> n'est pas trouv�e ");}
+  if (!servlet.isFile())
+    throw new HttpException (HTTP.STATUS_FORBIDDEN, servletName );
+  */
+
+  // assumption: in.getPath() is a string a/b/c, looks up servlet by c
+    final def extract():String ={
+      val  path = in.getPath();// retourne /servlet/repertoire/servletName
+      Console.println("HttpServletPro:path = "+path);
+      var repertoireExtract="";
+      var repertoireIdx = path.indexOf('/', 1);
+      Console.println("HttpServletPro:repIdx = "+repertoireIdx);
+      var servletIdx = path.indexOf('/', repertoireIdx+1 );
+      Console.println("HttpServletPro:servletIdx = "+servletIdx);
+      repertoireExtract = path.substring(repertoireIdx+1,servletIdx );
+      Console.println("HttpServletPro:repExtr = "+repertoireExtract);
+
+      var servletExtract = path.substring(servletIdx +1 );
+      Console.println("HttpServletPro:servletExtract = "+servletExtract);
+      var ma = new engine.Mapping();
+      //var servletRequested = ma.switch(servletExtract);
+      val res = ma.switch(servletExtract) + "$class";
+      Console.println("mapping: servletRequested = "+res);
+      res
+      //servletName = "/".concat(ma.switch(servletRequested));
+      //servlet = new File (HTTP.SERVER_LOCATION,HTTP.translateFilename("src"));
+      //servlet = new File (servlet,HTTP.translateFilename(repertoireExtract));
+      //servlet = new File (servlet,HTTP.translateFilename(servletName.substring(1)));
+
+      //return repertoireExtract ;
+    }
+
+
+
+
+  override def processRequest(out: HttpOutputStream): Unit ={
+    out.setHeader("Content-Type", "text/html");
+    val sc1:ScalaCookiee = new ScalaCookiee("Server", "test");
+    out.setCookie(sc1);
+    val x= out.sendHeaders ();
+
+    try{
+      /*
+      val idx = servletName.indexOf('.');
+      val s1 = servletName.substring(1,idx);
+      val s2 =repertoire.concat(".").concat(s1).concat("$class");
+      var servlet1 = Class.forName(s2);
+      */
+      Console.println("Getting class "+servletClassName);
+      val servlet1 = Class.forName( servletClassName );
+      var servletInstance = servlet1.newInstance().asInstanceOf[ScalaServlet];
+      servletInstance.doGet(out,info);
+   }
+
+    catch{
+      case e :ClassNotFoundException => System.out.println("error:attention le nom de la servlet est incorect");
+      case e :InstantiationException => System.out.println("InstantiationException"); e.printStackTrace();
+      case e : IllegalAccessException => System.out.println("IllegalAccessException");
+      case e:Exception =>
+	System.out.println("une erreur inconue dans al aclasse HttpServletPro");
+	e.printStackTrace();
+    }
+
+  }
+}
author	buraq <buraq@epfl.ch>	2004-07-26 13:18:44 +0000
committer	buraq <buraq@epfl.ch>	2004-07-26 13:18:44 +0000
commit	63f1dcdd145456457014a05e8378117bfaa292cb (patch)
tree	83558152d9577a36160c8b66a66410d5c4f675ce /sources
parent	9309cf418f5eefb20bfc07dcc4dcfab176c5bba4 (diff)
download	scala-63f1dcdd145456457014a05e8378117bfaa292cb.tar.gz scala-63f1dcdd145456457014a05e8378117bfaa292cb.tar.bz2 scala-63f1dcdd145456457014a05e8378117bfaa292cb.zip