Ticket #10510: 0001-WebSocketsImplemented.patch

new file Source/WebCore/platform/network/haiku/SocketStreamHandleHaiku.cpp

@@ +1 @@
+/*
+ * Copyright (C) 2009 Brent Fulgham.  All rights reserved.
+ * Copyright (C) 2009 Google Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "SocketStreamHandle.h"
+#include "SocketStreamError.h"
+
+#include "URL.h"
+#include "Logging.h"
+#include "NotImplemented.h"
+#include "SocketStreamHandleClient.h"
+
+#include <wtf/text/CString.h>
+#include <kernel/OS.h>
+#include<iostream>
+
+namespace WebCore {
+
+int SocketStreamHandle::async_read_push(const char * data,int length)
+{
+    RefPtr<SocketStreamHandle> protect(this);
+    (m_client)->didReceiveSocketStreamData(this,data,length);
+    std::cout<<"\nDATA PUSHED"<<data<<std::endl;
+    return 0;
+}
+long int async_read(void * ptrr)
+{
+    SocketStreamHandle * strm=(SocketStreamHandle *)ptrr;
+    char *array=new char[5025];
+    while(1)
+    {
+        std::cout<<"Entering-Loop with sock:"<<strm->sock<<std::endl;
+        int rd_bytes=(strm->sock)->Read(array,5024);
+        array[rd_bytes]='\0';
+        std::cout<<"Bytes:"<<rd_bytes<<"Read:"<<array<<std::endl;       
+        strm->async_read_push(array,rd_bytes);      
+    }
+    return 0;   
+}
+
+int SocketStreamHandle::async_sendPendingData()
+{
+    sendPendingData();
+    return 0;
+}
+
+long int async_write(void * ptrr)
+{
+    SocketStreamHandle * strm=(SocketStreamHandle *)ptrr;
+    status_t resp=(strm->sock)->WaitForWritable(B_INFINITE_TIMEOUT);
+    std::cout<<resp<<" "<<B_OK<<" "<<B_WOULD_BLOCK<<" "<<B_TIMED_OUT<<std::endl;;
+    if(resp==B_OK)
+        strm->async_sendPendingData();
+    else
+        return resp;
+    return 0;
+}
+
+SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
+    : SocketStreamHandleBase(url, client)
+{
+    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);
+    rd_thread=wr_thread=0;
+    unsigned int port = url.hasPort() ? url.port() : (url.protocolIs("wss") ? 443:80);
+    
+    peer = new BNetworkAddress(url.host().utf8().data(),port);
+    sock= new BSocket((*peer));
+    if(sock->IsConnected()==false)
+    {
+        status_t err=sock->Connect((*peer));
+        if(err!=B_OK)
+        {
+            (m_client)->didFailSocketStream(this,SocketStreamError(err));
+            return;
+        }
+    }
+    rd_thread=spawn_thread(async_read,"async_read",63,(void*)this);
+    resume_thread(rd_thread);
+    std::cout<<"New request:"<<url.host().utf8().data()<<":"<<port<<std::endl<<"Sock:"<<sock<<"Read-thread-id:"<<rd_thread<<std::endl;
+    m_state=Open;
+    m_client->didOpenSocketStream(this);
+    
+    //char *array=new char[1025];
+    //int rd_bytes=sock->Read(array,1024);
+    //m_client->didReceiveSocketStreamData(this,array,rd_bytes);
+}
+
+SocketStreamHandle::~SocketStreamHandle()
+{
+    LOG(Network, "SocketStreamHandle %p delete", this);
+    delete peer;
+    delete sock;
+    setClient(0);
+}
+
+
+
+int SocketStreamHandle::platformSend(const char* buffer, int length)
+{
+    int written=0,flag=0;
+    std::cout<<"To-Write:"<<buffer<<std::endl;
+    LOG(Network, "SocketStreamHandle %p platformSend", this);
+    if(sock->WaitForWritable(0)==B_OK)
+    {
+        written=sock->Write(buffer,length);
+        if(written<length)
+            flag=1;
+        std::cout<<"WRITTEN:"<<written<<std::endl;
+    }
+    else
+    {
+        flag=1;
+    }
+    if(flag==1)
+    {
+        std::cout<<"VOILA"<<std::endl;
+        wr_thread=spawn_thread(async_write,"async_write",63,(void*)this);
+        resume_thread(wr_thread);
+    }
+    return written;
+}
+
+void SocketStreamHandle::platformClose()
+{
+    LOG(Network, "SocketStreamHandle %p platformClose", this);
+    kill_thread(rd_thread);
+    if(wr_thread!=0)
+        kill_thread(wr_thread);
+    sock->Disconnect();
+    m_client->didCloseSocketStream(this);
+}
+
+void SocketStreamHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge&)
+{
+    notImplemented();
+}
+
+void SocketStreamHandle::receivedCredential(const AuthenticationChallenge&, const Credential&)
+{
+    notImplemented();
+}
+
+void SocketStreamHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge&)
+{
+    notImplemented();
+}
+
+void SocketStreamHandle::receivedCancellation(const AuthenticationChallenge&)
+{
+    notImplemented();
+}
+
+}  // namespace WebCore