int main(int n, char *a[])
{
SocketTCP myTCP;
int port = 10000;
if ( n > 1) port = atoi(a[1]);
printf("Video server start on port: %d\n", port);
if(!myTCP.OpenServer(port)) {
fprintf(stderr, "Open server fail\n");
return -2;
}
while(1) {
pthread_t myTread;
struct sockaddr_in addr;
myArgs ma;
try {
ma.tcp = myTCP.Accept(&addr);
ma.ip = inet_ntoa(addr.sin_addr);
printf("New Client Addr %u %s Port %d Family %d\n", *(UINT*)(&addr.sin_addr), ma.ip, addr.sin_port, addr.sin_family);
pthread_create( &myTread, NULL, startClient, (void*)&ma);
printf("Start...\n");
}
catch(...) {
fprintf(stderr,"exception!!\n");
return -1;
}
}
return 0;
}
void protocoloAceptar(int puerto, socket_t &socket_remoto, SocketTCP& server) {
server_logger::aceptada(puerto);
mensaje_t akw;
stringstream buffer;
client_logger::aceptada(puerto, buffer);
akw.cabecera = htonl(buffer.str().length());
uint32_t bytes_enviar = ntohl(akw.cabecera);
akw.mensaje = buffer.str().c_str();
server.enviar(socket_remoto, (void*)&akw.cabecera, sizeof(akw.cabecera));
server.enviar(socket_remoto, (void*)akw.mensaje, bytes_enviar);
}
SocketTCP SocketTCP::accept()
{
SocketTCP r;
sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
r.sock = ::accept(this->sock, (sockaddr*)&addr, &addrlen);
// Save Peer address
if (r.isOpen())
r.peerAddr = SocketAddr(ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port));
return r;
}
void tellService()
{
#ifndef USINGINTERNAL
system("sdmsg Banner");
#else
SocketTCP tcp;
if (tcp.Open(WIJET2_PORT, htonl(INADDR_LOOPBACK)) != 0) {
if(tcp.Send("Banner", 6) < 1)
fprintf(stderr, "Send fails\n");
tcp.Close();
}
else fprintf(stderr, "error to open socket???\n");
#endif
}
int getIP()
{
SocketTCP myTCP;
char buf[40];
unsigned int n = 0;
myTCP.Open(WIJET2_PORT, htonl(INADDR_LOOPBACK));
strcpy(buf, "AskIP");
if (myTCP.Send(buf, strlen(buf) +1) > 0) {
if (myTCP.Recv(buf, 40) > 0) {
sscanf(buf, "%u", &n);
}
}
return n;
}
int protocoloRespuesta(SocketTCP &cliente) {
mensaje_t akw;
cliente.recibir((void*)&akw.cabecera, sizeof(akw.cabecera));
akw.cabecera = ntohl(akw.cabecera);
akw.mensaje = new char[akw.cabecera];
cliente.recibir((void*)akw.mensaje, akw.cabecera);
for (unsigned int i = 0; i < akw.cabecera; i++) {
std::cout<<akw.mensaje[i];
}
delete[] akw.mensaje;
if (cliente.fallo()) {
return ERROR_PROTOCOLO;
} else {
return 0;
}
}
void* startClient(void *ma)
{
int rtn;
char buffer[125], cmd[250];
SocketTCP *myClient = ((myArgs*)ma)->tcp;
char *IP = ((myArgs*)ma)->ip;
myClient->SetRcvTime(5000);
rtn = myClient->Recv(buffer, 250);
if (rtn > 0) {
buffer[rtn] = 0;
if (strstr(buffer,":")) // full mrl
sprintf(cmd, "%s %s\n", myXine, buffer);
else
sprintf(cmd, "%s tcp://%s:%s\n", myXine, IP, buffer);
fprintf(stderr, cmd);
system(cmd);
}
delete myClient;
printf("Done \n");
pthread_exit(0);
}
int main(int argc, char* argv[]) {
ServerSocketTCP* serverSocket = new ServerSocketTCP(12345);
serverSocket->bindPort();
serverSocket->startListen();
SocketTCP* s = serverSocket->acceptConnection();
for (int i = 0; i < 255; i++) {
DataPayload* data = s->receiveData();
cout << "Data Received from ["
<< s->getIPAddress() << ":" << s->getPortNumber()
<< "]: " << data->getDataAsString() << endl;
delete data;
string message = "\"Message to client ";
message += cpputil::Functions::numberToString(i);
message += ".\"";
data = new DataPayload(message);
s->sendData(data);
delete data;
}
s->closeConnection();
delete s;
serverSocket->releasePort();
delete serverSocket;
return 0;
}
////////////////////////////////////////////////////////////
/// Wait for a connection (must be listening to a port).
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketTCP::Accept(SocketTCP& Connected, IPAddress* Address)
{
// Address that will be filled with client informations
sockaddr_in ClientAddress;
SocketHelper::LengthType Length = sizeof(ClientAddress);
// Accept a new connection
Connected = accept(mySocket, reinterpret_cast<sockaddr*>(&ClientAddress), &Length);
// Check errors
if (!Connected.IsValid())
{
if (Address)
*Address = IPAddress();
return SocketHelper::GetErrorStatus();
}
// Fill address if requested
if (Address)
*Address = IPAddress(inet_ntoa(ClientAddress.sin_addr));
return Socket::Done;
}
bool HttpRequesterReaderServer::run(SocketTCP& requester_socket)
{
bool is_end_request = false;
char c;
string request;
string attribute_header_request;
vector<string> header_request;
while(!is_end_request) {
requester_socket.receive(&c);
if(c == '\r') {
header_request.push_back(attribute_header_request);
requester_socket.receive(&c);
if(c == '\r') {
is_end_request = true;
} else if(c == '\n') {
requester_socket.receive(&c);
if(c == '\r') {
requester_socket.receive(&c);
if(c == '\n') {
is_end_request = true;
} else {
return false;
}
} else {
attribute_header_request = c;
}
} else {
attribute_header_request = c;
}
} else if(c == '\n') {
header_request.push_back(attribute_header_request);
if(c == '\n') {
is_end_request = true;
} else {
attribute_header_request = c;
}
} else {
attribute_header_request += c;
}
}
if(header_request.size() > 0) {
string cmd;
string protocol;
stringstream ss;
ss << header_request[0];
ss >> cmd;
ss >> request;
ss >> protocol;
if(!ss.fail()) {
if(cmd != "GET" || request.size() == 0 || request[0] != '/' || protocol != "HTTP/1.1") {
return false;
}
request.erase(request.begin());
} else {
return false;
}
} else {
void Http::proc(void* /*param*/)
{
bStop = false;
if (!Paths::Exists(Paths::ExtractFilePath(filename)))
Paths::MakeDir(Paths::ExtractFilePath(filename));
SocketTCP sock;
char buffer[4096];
String realFilename = filename;
String tmpFile = String(filename) << ".part";
Stream f(tmpFile, Yuni::Core::IO::OpenMode::write);
int count;
int crfound = 0;
int lffound = 0;
if (!f.opened())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not open file " << tmpFile << " for writing !");
return; // Error can't open file
}
/* open the socket and connect to the server */
sock.open(servername, 80);
if(!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not open socket !");
f.close();
remove(tmpFile.c_str());
return;
}
sock.setNonBlockingMode(true); // We want it to be able to detect end of file ;)
String tmpBuf;
tmpBuf << "GET " << _request << " HTTP/1.0\r\nHost:" << servername << "\nAccept: */*\r\nUser-Agent: TA3D\r\nConnection: close\r\n\r\n";
uint32 timer(msec_timer);
sock.send(tmpBuf.data(), tmpBuf.size());
if (!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not send request to server !");
f.close();
remove(tmpFile.c_str());
return;
}
pos = 0;
size = 0;
String header;
while (!bStop)
{
timer = msec_timer;
do
{
count = sock.recv(buffer, sizeof(buffer) - 1);
if (count == 0)
{
if (suspend(1))
{
sock.close();
f.close();
remove(tmpFile.c_str());
return;
}
}
}
while(count == 0 && msec_timer - timer < 60000 && !bStop);
if (msec_timer - timer >= 60000 || bStop)
sock.close();
if(count < 0)
{
sock.close();
f.close();
if (pos == size)
{
Paths::Files::Copy(tmpFile, realFilename, true);
LOG_DEBUG(LOG_PREFIX_NET << "File successfully downloaded : " << realFilename);
}
else
{ LOG_DEBUG(LOG_PREFIX_NET << "Download failed : " << realFilename); }
remove(tmpFile.c_str());
return;
}
if(count > 0)
{
/* parse out the HTTP header */
if(lffound < 2)
{
int i;
for (i = 0; i < count; ++i)
{
header << buffer[i];
if(buffer[i] == 0x0D)
++crfound;
else
{
if (buffer[i] == 0x0A)
++lffound;
else
/* reset the CR and LF counters back to 0 */
crfound = lffound = 0;
}
if (lffound == 2)
{
/* i points to the second LF */
/* output the buffer to the file */
f.write( (char*)(buffer+i+1), count-i-1 );
pos += count-i-1;
size = Math::Max(size, pos);
break;
}
}
if (lffound >= 2)
{
header.toLower();
String::Size offset = header.find("content-length: ");
if (offset != String::npos)
{
header.erase(0, offset + 16);
header.trimRight(" \n\t");
size = header.to<int>();
LOG_DEBUG("header = " << header);
LOG_DEBUG("Http: size = " << size);
}
}
}
else
{
f.write( (const char*)buffer, count );
pos += count;
size = Math::Max(size, pos);
}
}
}
sock.close();
f.close();
remove(tmpFile.c_str());
LOG_ERROR(LOG_PREFIX_NET << "Http: Download interrupted!");
}
bool Http::getFile( const String &filename, const String &servername, const String &_request )
{
SocketTCP sock;
char buffer[4096];
Stream f(filename, Yuni::Core::IO::OpenMode::write);
int count;
int crfound = 0;
int lffound = 0;
if (!f.opened())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not open file " << filename << " for writing !");
return true; // Error can't open file
}
/* open the socket and connect to the server */
sock.open(servername, 80);
if(!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not open socket !");
f.close();
return true;
}
sock.setNonBlockingMode(true); // We want it to be able to detect end of file ;)
String tmpBuf;
tmpBuf << "GET " << _request << " HTTP/1.0\r\nHost:" << servername << "\nAccept: */*\r\nUser-Agent: TA3D\r\nConnection: close\r\n\r\n";
uint32 timer(msec_timer);
sock.send(tmpBuf.data(), tmpBuf.size());
if (!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpGetFile: Could not send request to server !");
f.close();
return true;
}
while (true)
{
timer = msec_timer;
do
{
count = sock.recv(buffer, sizeof(buffer) - 1);
rest(1);
}
while(count == 0 && msec_timer - timer < 1000);
if (msec_timer - timer >= 1000)
sock.close();
if(count < 0)
{
sock.close();
f.close();
return false;
}
if(count > 0)
{
/* parse out the HTTP header */
if(lffound < 2)
{
int i;
for (i = 0; i < count; ++i)
{
if(buffer[i] == 0x0D)
++crfound;
else
{
if (buffer[i] == 0x0A)
++lffound;
else
/* reset the CR and LF counters back to 0 */
crfound = lffound = 0;
}
if (lffound == 2)
{
/* i points to the second LF */
/* output the buffer to the file */
f.write( (const char*)(buffer+i+1), count-i-1 );
break;
}
}
}
else
f.write( (const char*)buffer, count );
}
}
sock.close();
f.close();
return true;
}
String Http::request( const String &servername, const String &_request )
{
SocketTCP sock;
char buffer[4096];
String f;
int count;
int crfound = 0;
int lffound = 0;
/* open the socket and connect to the server */
sock.open(servername, 80);
if(!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpRequest: Could not open socket !");
return nullptr;
}
sock.setNonBlockingMode(true); // We want to be able to detect end of transmission :p
f.clear();
String tmpBuf;
tmpBuf << "GET " << _request << " HTTP/1.0\r\nHost:" << servername << "\nAccept: */*\r\nUser-Agent: TA3D\r\n\r\n";
uint32 timer(msec_timer);
sock.send( tmpBuf.data(), tmpBuf.size());
if (!sock.isOpen())
{
LOG_ERROR(LOG_PREFIX_NET << "httpRequest: Could not send request to server !");
return nullptr;
}
while (true)
{
timer = msec_timer;
do
{
count = sock.recv(buffer, sizeof(buffer) - 1);
rest(1);
}
while(count == 0 && msec_timer - timer < 1000);
if (msec_timer - timer >= 1000)
sock.close();
if(count < 0)
{
sock.close();
return f;
}
if(count > 0)
{
/* parse out the HTTP header */
if(lffound < 2)
{
int i;
for (i = 0; i < count; ++i)
{
if(buffer[i] == 0x0D)
++crfound;
else
{
if (buffer[i] == 0x0A)
++lffound;
else
/* reset the CR and LF counters back to 0 */
crfound = lffound = 0;
}
if (lffound == 2)
{
/* i points to the second LF */
/* NUL terminate the string and put it in the buffer string */
buffer[count] = 0x0;
f += buffer+i+1;
break;
}
}
}
else
{
buffer[count] = 0x0;
f += buffer;
}
}
}
sock.close();
return f;
}
