boolean GPRSbee::httpPostTextFile(char *serverName, char *serverPort, char *serverURL, char *fileContent, byte maxNumConnectAttempts) {
// returns true if the status line of the response contains the http code : 200
boolean requestSuccess = false;
long fileContentLength = 0;
while(fileContent[fileContentLength] != '\0') fileContentLength++;
boolean tcpConnectSuccess = tcpConnect(serverName, serverPort, maxNumConnectAttempts);
if(tcpConnectSuccess) {
char httpResponseStatusLineBuffer[60];
char formFieldName[] = HTTP_POST_FILE_DEFAULT_FORM_FIELD_NAME;
requestAT(F("AT+CIPSEND"), 2, AT_CIPSEND_RESP_TIMOUT_IN_MS);
echoHttpRequestInitHeaders(serverName, serverURL, "POST");
echoHttpPostFileRequestAdditionalHeadersPart1(fileContentLength, formFieldName);
serialConnection.print((char) 26);
delay(300);
requestAT(F("AT+CIPSEND"), 2, AT_CIPSEND_RESP_TIMOUT_IN_MS);
serialConnection.print(fileContent);
serialConnection.print((char) 26);
delay(300);
requestAT(F("AT+CIPSEND"), 2, AT_CIPSEND_RESP_TIMOUT_IN_MS);
echoHttpPostFileRequestAdditionalHeadersPart2();
serialConnection.print((char) 26);
retrieveHttpResponseStatusLine(httpResponseStatusLineBuffer, sizeof(httpResponseStatusLineBuffer), HTTP_RESP_TIMOUT_IN_MS);
if(strstr(httpResponseStatusLineBuffer, "200") != NULL) requestSuccess = true;
tcpClose();
}
return requestSuccess;
}
void RFIDMonitorDaemon::start()
{
if(m_localServer->listen(m_serverName)){
qDebug() << QString("Server name: %1").arg(m_localServer->serverName());
initMonitor();
QThread *consoleThread = new QThread(this);
Console *console = new Console;
console->moveToThread(consoleThread);
connect(consoleThread, SIGNAL(destroyed()), console, SLOT(deleteLater()));
connect(consoleThread, &QThread::started, console, &Console::run);
connect(console, &Console::exitApp, consoleThread, &QThread::quit);
connect(console, SIGNAL(exitApp()), qApp, SLOT(quit()));
// consoleThread->start();
QTimer::singleShot(100, this, SLOT(tcpConnect()));
}else{
qDebug() << "Could not start IPC server";
}
if(!m_udpSocket->bind(QHostAddress::Any, 9999))
qDebug() << QString("Couldn't listening to broadcast");
}
// Establish a connection using an SSL layer
connection *sslConnect(SSL_CTX* ctx) {
if (ctx == NULL) return NULL;
connection *c;
c = malloc(sizeof (connection));
c->sslHandle = NULL;
c->socket = tcpConnect();
if (c->socket) {
// Create an SSL struct for the connection
c->sslHandle = SSL_new(ctx);
if (c->sslHandle == NULL)
ERR_print_errors_fp(stderr);
// Connect the SSL struct to our connection
if (!SSL_set_fd(c->sslHandle, c->socket))
ERR_print_errors_fp(stderr);
// Initiate SSL handshake
if (SSL_connect(c->sslHandle) != 1)
ERR_print_errors_fp(stderr);
}
else {
perror("Connect failed");
}
return c;
}
int Socket::init()
{
struct sockaddr_in servaddr;
int optval = 1;
sockfd = tcpSocket(AF_INET, SOCK_STREAM, 0);
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
// Eliminates "Address already in use" error from bind
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
(const void *)&optval, sizeof(int)) < 0)
Error::sys("setsockopt");
if (socktype == SRV_SOCKET){
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
tcpBind(sockfd, (SA *) &servaddr, sizeof(servaddr));
tcpListen(sockfd, LISTENQ);
} else if (socktype == CLI_SOCKET){
if (inet_pton(AF_INET, host, &servaddr.sin_addr) < 0)
Error::quit("inet_pton error for %s", host);
tcpConnect(sockfd, (SA *)&servaddr, sizeof(servaddr));
} else {
Error::quit("Unkown SockType");
}
/* For client, this sockfd is connfd,
* for server, this sockfd is listenfd. */
return sockfd;
}
boolean GPRSbee::httpGet(char *serverName, char *serverPort, char *serverURL, byte maxNumConnectAttempts) {
// returns true if the status line of the response contains the http code : 200
boolean requestSuccess = false;
boolean tcpConnectSuccess = tcpConnect(serverName, serverPort, maxNumConnectAttempts);
if(tcpConnectSuccess) {
char httpResponseStatusLineBuffer[60];
requestAT(F("AT+CIPSEND"), 2, AT_CIPSEND_RESP_TIMOUT_IN_MS);
echoHttpRequestInitHeaders(serverName, serverURL, "GET");
serialConnection.print('\n');
serialConnection.print((char) 26);
retrieveHttpResponseStatusLine(httpResponseStatusLineBuffer, sizeof(httpResponseStatusLineBuffer), HTTP_RESP_TIMOUT_IN_MS);
if(strstr(httpResponseStatusLineBuffer, "200") != NULL) requestSuccess = true;
tcpClose();
}
return requestSuccess;
}
bool SSMTP::send(MIMEmessage *message)
{
log.clear();
int mSize = message->getMIMEText().toLatin1().size();
/* calc timeout for slowly 56 kbps connection */
messageRespTimeout = (mSize / (56000/8)) * 1000;
if (!tcpConnect()) return false;
if (!waitForResponse()) return false;
if (!checkRespCode(220)) return false;
if (!sendCmd("EHLO " + smtp_name,250)) return false;
if (!smtp_user.isEmpty() || smtp_pass.isEmpty())
{
if (!sendCmd("AUTH LOGIN",334)) return false;
if (!sendCmd(smtp_user.toUtf8().toBase64(),334)) return false;
if (!sendCmd(smtp_pass.toUtf8().toBase64(),235)) return false;
}
if (!sendCmd("MAIL FROM: " + message->getFromEmail(),250)) return false;
for (int i=0; i < message->rcptList()->count(); ++i)
{
if (!sendCmd("RCPT TO: " + message->rcptList()->at(i),250)) return false;
}
if (!sendCmd("DATA",354)) return false;
sendText(message->getMIMEText(),true);
sendText(".");
if (!waitForResponse(true)) return false;
if (!checkRespCode(250)) return false;
if (!sendCmd("QUIT",221)) return false;
tcpDisconnect();
return true;
}
SOCKET WSocket::tcpConnectA(const LPSTR host, const WORD port)
{
WORD tcpPort = SWAP_WORD(port);
//Obtain the data the remote server.
SOCKADDR_STORAGE *destAddrIpv4 = NULL;
SOCKADDR_STORAGE *destAddrIpv6 = NULL;
{
struct addrinfo *aiList;
if(CWA(ws2_32, getaddrinfo)(host, NULL, NULL, &aiList) != 0)return INVALID_SOCKET;
struct addrinfo *cur = aiList;
while(cur)
{
if(cur->ai_family == AF_INET)destAddrIpv4 = (SOCKADDR_STORAGE *)Mem::copyEx(cur->ai_addr, cur->ai_addrlen);
else if(cur->ai_family == AF_INET6)destAddrIpv6 = (SOCKADDR_STORAGE *)Mem::copyEx(cur->ai_addr, cur->ai_addrlen);
cur = cur->ai_next;
}
CWA(ws2_32, freeaddrinfo)(aiList);
}
SOCKET s = INVALID_SOCKET;
//FIXME: change prioretet when IPv6 will become porulyarnee IPv4.
if(destAddrIpv4 != NULL)
{
((SOCKADDR_IN *)destAddrIpv4)->sin_port = tcpPort;
s = tcpConnect(destAddrIpv4);
}
//Xs on how much it is logical to relanyh conditions.
if(destAddrIpv6 != NULL && s == INVALID_SOCKET)
{
((SOCKADDR_IN6 *)destAddrIpv6)->sin6_port = tcpPort;
s = tcpConnect(destAddrIpv6);
}
Mem::free(destAddrIpv4);
Mem::free(destAddrIpv6);
return s;
}
SOCKET WSocket::tcpConnectA(const LPSTR host, const WORD port)
{
WORD tcpPort = SWAP_WORD(port);
//Получаем данные удаленного сервера.
SOCKADDR_STORAGE *destAddrIpv4 = NULL;
SOCKADDR_STORAGE *destAddrIpv6 = NULL;
{
struct addrinfo *aiList;
if(CWA(ws2_32, getaddrinfo)(host, NULL, NULL, &aiList) != 0)return INVALID_SOCKET;
struct addrinfo *cur = aiList;
while(cur)
{
if(cur->ai_family == AF_INET)destAddrIpv4 = (SOCKADDR_STORAGE *)Mem::copyEx(cur->ai_addr, cur->ai_addrlen);
else if(cur->ai_family == AF_INET6)destAddrIpv6 = (SOCKADDR_STORAGE *)Mem::copyEx(cur->ai_addr, cur->ai_addrlen);
cur = cur->ai_next;
}
CWA(ws2_32, freeaddrinfo)(aiList);
}
SOCKET s = INVALID_SOCKET;
//FIXME: поменять приоретет, когда IPv6 станет порулярнее IPv4.
if(destAddrIpv4 != NULL)
{
((SOCKADDR_IN *)destAddrIpv4)->sin_port = tcpPort;
s = tcpConnect(destAddrIpv4);
}
//Хз на сколько это логично в релаьных условиях.
if(destAddrIpv6 != NULL && s == INVALID_SOCKET)
{
((SOCKADDR_IN6 *)destAddrIpv6)->sin6_port = tcpPort;
s = tcpConnect(destAddrIpv6);
}
Mem::free(destAddrIpv4);
Mem::free(destAddrIpv6);
return s;
}
/*
* Make a connection to the given <host> and <port>. Incoming data on this socket is reported using
* the callback installed with nsOnSocket(). The new file descriptor is returned, or -1 if an error
* occurred.
*/
int nsConnect(NS *ns, const char *host, int port)
{
int fd = tcpConnect(host, port);
if (fd >= 0) {
ns_add_connection(ns, fd);
}
return fd;
}
void RFIDMonitorDaemon::tcpDisconnected()
{
if(isConnected){
QJsonObject obj;
obj.insert("full", QJsonValue(false));
// Inform RFIDMonitor that the server is no more connected
ipcSendMessage(buildMessage(QJsonObject(), "SLEEP").toJson());
ipcSendMessage(buildMessage(obj, "FULL-READ").toJson());
isConnected = false;
}
// Try to reconnect the server after 5 seconds
QTimer::singleShot(5000, this, SLOT(tcpConnect()));
}
Widget::Widget( QWidget * parent )
: QWidget( parent )
{
createWidgets();
setWindowTitle( tr("Echo client %1").arg( PORT ) );
connect( &socket, SIGNAL( connected() ), SLOT( slotConnected() ) );
connect( &socket, SIGNAL( disconnected() ), SLOT( slotDisconnected() ) );
connect( &socket, SIGNAL( readyRead() ), SLOT( slotRead() ) );
tcpConnect();
}
/* Main Entry */
int main(int argc, char **argv)
{
// init connection object
Connection conn;
memset(&conn, 0, sizeof(conn));
conn.port = PORT; // assign default port
conn.host = HOST;
// Parse arguments
parseArguments(argc, argv, &conn);
// init SSL library
conn.sslContext = initSSLContext(CLIENT_CERTIFICATE, CA_CERTIFICATE);
SSL_CTX_set_options(conn.sslContext, SSL_OP_NO_SSLv2);
SSL_CTX_set_cipher_list(conn.sslContext, "SHA1");
// Connect
if (tcpConnect(&conn) < 0){
tcpDisconnect(&conn);
exit(0);
}
SSL * ssl = SSL_new(conn.sslContext);
BIO * sbio = BIO_new_socket(conn.socket, BIO_NOCLOSE);
SSL_set_bio(ssl, sbio, sbio);
int ret;
ret = SSL_connect(ssl);
if (ret <= 0){
printf(FMT_CONNECT_ERR);
handleError(ssl, ret);
}
else{
// Process Message
if (checkServerCertification(ssl) == OK){
processMessage(ssl);
}
}
// close ssl connection
if (!SSL_shutdown(ssl)){
tcpDisconnect(&conn);
SSL_shutdown(ssl);
}
SSL_free(ssl);
// Disconnect
tcpDisconnect(&conn);
destroySSLContext(conn.sslContext);
return 1;
}
void
main( int argc, char **argv )
{
SOCKET sock;
int arg;
char *host = DEFAULT_HOST;
u_short port = (u_short)DEFAULT_PORT;
for( arg = 1; arg < argc; arg++ )
{
if ( argv[ arg ][0] != '-' )
{
fprintf( stderr, "Invalid command line argument: %s\n", argv[ arg ] );
exit(1);
}
switch( argv[ arg ][1] )
{
case 'h':
printf( "-t <host>\tTarget host name (default 'localhost')\n" );
printf( "-p <port>\tTarget port number (default 16903)\n" );
printf( "-e\t\tAES Mode ECB\n" );
printf( "-v\t\tVerbose\n" );
exit(0);
case 't' : host = argv[ ++arg ]; break;
case 'p' : port = atoi( argv[ ++arg ] ); break;
case 'e' : sessKeyMode = CRYPT_MODE_ECB; break;
case 'v' : verbose = TRUE; break;
default:
fprintf( stderr, "Invalid command line flag: %s\n", argv[ arg ] );
exit(1);
}
}
if ( ! initCrypt() ) exit(1);
sock = tcpConnect( host, port );
if ( ! initSession( sock ) ) exit(1);
if ( ! clientRequest( sock, host, port ) ) exit(1);
shutdown( sock, 2 );
closesocket( sock );
if ( WSACleanup() == SOCKET_ERROR )
fprintf( stderr, "Problem with socket cleanup\n" );
termCrypt();
exit(0);
}
connection *sslConnect (void)
{
connection *c;
c = malloc (sizeof (connection));
c->sslHandle = NULL;
c->sslContext = NULL;
c->socket = tcpConnect ();
if (c->socket)
{
// Register the error strings for libcrypto & libssl
SSL_load_error_strings ();
// Register the available ciphers and digests
SSL_library_init ();
// New context saying we are a client, and using SSL 2 or 3
c->sslContext = SSL_CTX_new (SSLv23_client_method ());
if (c->sslContext == NULL)
{
ERR_print_errors_fp (stderr);
}
// Create an SSL struct for the connection
c->sslHandle = SSL_new (c->sslContext);
if (c->sslHandle == NULL)
{
ERR_print_errors_fp (stderr);
}
// Connect the SSL struct to our connection
if (!SSL_set_fd (c->sslHandle, c->socket))
{
ERR_print_errors_fp (stderr);
}
// Initiate SSL handshake
if (SSL_connect (c->sslHandle) != 1)
{
ERR_print_errors_fp (stderr);
}
}
else
{
perror ("Connect failed");
}
return c;
}
/*
* Add an output channel to <logger> that sends messages over a TCP connection
* to port <port> on host <host>. If no connection could be opened, -1 is
* returned and the channel is not created.
*/
int logToTCP(Logger *logger, const char *host, int port)
{
int fd;
if ((fd = tcpConnect(host, port)) < 0)
return -1;
else {
pthread_mutex_lock(&logger->access);
LOG_Output *out = log_create_output(logger, LOG_OT_TCP);
out->u.fd = fd;
pthread_mutex_unlock(&logger->access);
return 0;
}
}
int myregister(){
string file;
cout<< "Registering server...\n";
int sock=tcpConnect("nwprog1.netlab.hut.fi","3000");
if (sock==-1){
printf("Registration Failed\n");
return -1;
}
int totalWriteByte=0;
/*start of sending PUT requst to server*/
string str("PUT /servers-behzad.txt");
str.append(" HTTP/1.1\r\nHost: http://nwprog1.netlab.hut.fi:3000");
str.append("\r\nIam: BEHZAD\r\nContent-Type: text/plain\r\nContent-Length: ");
file.append(runningHost);
file.append(":");
file.append(integerToString(SERV_PORT));
str.append(integerToString((int)file.length()));
str.append("\r\n\r\n");
str.append(file);
if ((totalWriteByte=writeString(sock,str))==-1){
cout<<"Error in sending Registration request";
return -1;
}
/*end of sending PUT requst to server*/
/*read response*/
string headers;
headers=readResponse(sock);
if (strcmp((const char *)headers.c_str(),"-1")==0)
{
cout<<"Error in reading response from server\n";
close(sock);
return -1;
}
close(sock);
return 0;
}
MailConnection::MailConnection(std::string address, std::string login, std::string password, int port/* = 0*/)
: _address(address), _port(port), valid(true), _sock(0), conn(nullptr), originalLogin(login)
{
// convert login and password to base64 encoding
_login = base64_encode(reinterpret_cast<const unsigned char*>(login.c_str()),login.size());
_password = base64_encode(reinterpret_cast<const unsigned char*>(password.c_str()),password.size());
if (!tcpConnect())
{
valid = false;
return;
}
if (!sslConnect())
{
valid = false;
return;
}
if (!authenticate())
valid = false;
}
// Establish a connection using an SSL layer
int SSLSocket::sslConnect(const char *addr, uint16_t port, int timeout) {
conn.sslHandle = NULL;
conn.socket = tcpConnect(addr, port, timeout);
// Create an SSL struct for the connection
conn.sslHandle = SSL_new(ctx);
if (conn.sslHandle == NULL) {
close();
throw SSLSocketException ( "Could not create SSL object." );
}
// Connect the SSL struct to our connection
if (!SSL_set_fd(conn.sslHandle, conn.socket)) {
close();
throw SSLSocketException ( "Could not connect the SSL object to the socket." );
}
// Initiate SSL handshake
if (SSL_connect(conn.sslHandle) != 1) {
close();
throw SSLSocketException ( "Error during SSL handshake." );
}
return conn.socket;
}
boolean GPRSbee::httpPostEncodedData(char *serverName, char *serverPort, char *serverURL, char *encodedData, byte maxNumConnectAttempts) {
// encodedData example : "A=1&B=2&C=3" (URL encoded data)
// returns true if the status line of the response contains the http code : 200
boolean requestSuccess = false;
long encodedDataLength = 0;
while(encodedData[encodedDataLength] != '\0') encodedDataLength++;
boolean tcpConnectSuccess = tcpConnect(serverName, serverPort, maxNumConnectAttempts);
if(tcpConnectSuccess) {
char httpResponseStatusLineBuffer[60];
requestAT(F("AT+CIPSEND"), 2, AT_CIPSEND_RESP_TIMOUT_IN_MS);
echoHttpRequestInitHeaders(serverName, serverURL, "POST");
echoHttpPostURLEncodedRequestAdditionalHeaders(encodedDataLength);
serialConnection.print(encodedData);
serialConnection.print((char) 26);
retrieveHttpResponseStatusLine(httpResponseStatusLineBuffer, sizeof(httpResponseStatusLineBuffer), HTTP_RESP_TIMOUT_IN_MS);
if(strstr(httpResponseStatusLineBuffer, "200") != NULL) requestSuccess = true;
tcpClose();
}
return requestSuccess;
}
void home_page(char *host, char *fname)
{
int fd, n;
char line[MAXLINE];
rio_t rio;
fd = tcpConnect(host, SERV); /* blocking connect() */
n = snprintf(line, sizeof(line), GET_CMD, fname,host);
rio_writen(fd, line, n);
rio_readinitb(&rio, fd);
while ((n = rio_readlineb(&rio, line, sizeof(line))) > 1)
{
if (strcmp(line,END_OF_HTML) == 0)
{
break;
}
parseUrl(line,host);
}
printf("end-of-file on home page\n");
close(fd);
}
void *do_get_read(void *vptr)
{
int fd, n;
char line[MAXLINE];
struct file *fptr;
rio_t rio;
fptr = (struct file *) vptr;
fd = tcpConnect(fptr->f_host, SERV);
fptr->f_fd = fd;
printf("do_get_read for name:%s host:%s, fd %d, thread %d\n",
fptr->f_name,fptr->f_host, fd, fptr->f_tid);
write_get_cmd(fptr); /* write() the GET command */
rio_readinitb(&rio,fd);
while((n = rio_readlineb(&rio,line,sizeof(line))) > 1)
{
printf("read %d bytes from name:%s host:%s\n", n, fptr->f_name,fptr->f_host);
if (strcmp(line, END_OF_HTML) == 0)
{
break;
}
parseUrl(line,fptr->f_host);
}
printf("end-of-file on name:%s host:%s\n", fptr->f_name,fptr->f_host);
close(fd);
fptr->f_flags = F_DONE; /* clears F_READING */
pthread_mutex_lock(&ndone_mutex);
ndone++;
pthread_cond_signal(&ndone_cond);
pthread_mutex_unlock(&ndone_mutex);
return(fptr); /* terminate thread */
}
void QCOMM::readudppendingdatagrams()
{
char data[512];
while(udpsocket->hasPendingDatagrams()){
unsigned int len = udpsocket->read(data,512);
if(len<sizeof(MDHEADER))
continue;
HEARTBEATRESULT *heartack = (HEARTBEATRESULT *)data;
if(!checkMdHeart(heartack->header))
continue;
unsigned short packsize = heartack->header.sizeofpack;
if (packsize<len)
continue;
//if(heartack->header.crc!=qChecksum((char *)&(heartack->funcode),
// len-sizeof (heartack->header)))
// continue;
switch (heartack->funcode){
case UDP_TCPCONNECT:{
QHostAddress addr(ntohl(heartack->ipaddr));
tcpConnect(addr,heartack->port);
break;
}
case UDP_SSHCONNECT:{
unsigned int ipaddr = *(unsigned int *)(heartack->ipaddr);
sshConnect(QHostAddress("ipaddr"),ipaddr);
break;
}
case UDP_MACHINEINFO:
break;
case UDP_HEARTBEATINC:
break;
default:
break;
}
}
}
int unregister(){
cout<<"\nRemoving server registeration...\n";
int sock=tcpConnect("nwprog1.netlab.hut.fi","3000");
if (sock==-1){
printf("Failed\n");
return -1;
}
int totalWriteByte=0;
/*start of sending PUT requst to server*/
string str("PUT /servers-behzad.txt");
str.append(" HTTP/1.1\r\nHost: http://nwprog1.netlab.hut.fi:3000");
str.append("\r\nIam: BEHZAD\r\nContent-Type: text/plain\r\nContent-Length: 1\r\n\r\n\n");
if ((totalWriteByte=writeString(sock,str))==-1){
cout<<"Error in sending request";
return -1;
}
/*end of sending PUT requst to server*/
/*read response*/
string headers;
headers=readResponse(sock);
if (strcmp((const char *)headers.c_str(),"-1")==0)
{
close(sock);
return -1;
}
close(sock);
return 0;
}
int HttpClient::requestHeader(Url &url, string&headerStr) {
// construct a request
string requestStr;
string path = url.getPath();
if (path.empty())
path = "/";
requestStr = "HEAD " + path + " HTTP/1.0\r\nHost: " + url.getHost()
+ "\r\nUser-Agent: openSE/1.0 (Ubuntu11.04)\r\nAccept-Language: zh,en-us\r\nAccept-Charset: gb2312,utf-8\r\nConnection: Keep-Alive\r\n\r\n";
cout << "requestStr:\n" << requestStr << endl;
// send request:
if (url.getHost() != _preHost) {
if (_preSockFd != -1) {
closesocket(_preSockFd);
_preSockFd = -1;
}
}
int sockFd;
bool sendSuccess = false;
// try to use previous connection
if (_preSockFd != -1) {
sockFd = _preSockFd;
if (rio_writen(sockFd, requestStr.c_str(), requestStr.size()) == -1) {
cerr << "use previous connection:rio_writen error !" << endl;
closesocket(_preSockFd);
_preSockFd = -1;
} else
sendSuccess = true;
}
if (!sendSuccess) {
// try to creat a new connection
sockFd = tcpConnect(url.getIp(), url.getPort());
if (sockFd == -1) {
cerr << "tcpConnect error" << endl;
return -1;
}
// try to use new connection
if (rio_writen(sockFd, requestStr.c_str(), requestStr.size()) == -1) {
cerr << "rio_writen error for requestStr:" << requestStr << endl;
closesocket(sockFd);
return -1;
}
}
headerStr.reserve(1024);
int timeoutSeconds = DEFAULT_TIMEOUT_SECONDS;
int bytesRead = 0;
// set socket to no block type
#ifdef _MSC_VER
#else
int flags;
flags = fcntl(sockFd, F_GETFL, 0);
if (flags < 0) {
cerr << "1.fcntl() error in receiveHeader()< 0" << endl;
return -1;
}
flags |= O_NONBLOCK;
if (fcntl(sockFd, F_SETFL, flags) < 0) {
cerr << "2.fcntl() error in receiveHeader" << endl;
return -1;
}
#endif
int newlines = 0;
while (newlines < 2) {
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(sockFd, &rfds);
struct timeval tv;
tv.tv_sec = timeoutSeconds;
tv.tv_usec = 0;
int selectRet;
if (timeoutSeconds >= 0) // wait DEFAULT_TIMEOUT_SECONDS seconds
selectRet = select(sockFd + 1, &rfds, NULL, NULL, &tv);
else // wait infinitely
selectRet = select(sockFd + 1, &rfds, NULL, NULL, NULL);
if (selectRet == 0 && timeoutSeconds < 0) {
cerr << "select should wait infinitely" << endl;
bytesRead = -1;
break;
} else if (selectRet == -1) {
cerr << "select error" << endl;
bytesRead = -1;
break;
} else if (selectRet == 0) {
cerr << "select timeout after " << timeoutSeconds << " seconds" << endl;
bytesRead = -1;
break;
}
char c;
int ret = recv(sockFd, &c, 1, 0);
if (ret <= 0) {
cerr << "read error" << endl;
bytesRead = -1;
break;
}
headerStr += c;
++bytesRead;
if (c == '\r') { /* Ignore CR */
continue;
} else if (c == '\n') /* LF is the separator */
newlines++;
else
newlines = 0;
}
if (bytesRead <= 0) {
cerr << "receiveHeader error" << endl;
closesocket(sockFd);
_preSockFd = -1;
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
struct sockaddr_in serv_addr;
int port;
struct hostent hptr;
int serv_sockfd;
int isConnected,pfd,rc;
char buff[1024],msg[1024];
if(argc!=4)
{
fprintf(stderr,"ERROR \t: USAGE : echocli <ip/host-name> <port> <pipe-fd>\n");
return EXIT_FAILURE;
}
pfd = atoi(argv[3]);
Getsockaddr(argv[1],&serv_addr);
char ipstr[20];
memset(ipstr,0,sizeof(ipstr));
inet_ntop(AF_INET, &(serv_addr.sin_addr), ipstr, sizeof(ipstr));
port = atoi(argv[2]);
if(port < 1025)
{
fprintf(stderr,"ERROR \t: PORT NUMBER SHOULD BE GREATER THAN 1024\n");
return EXIT_FAILURE;
}
//serv_sockfd = createtcpsocket(port,&serv_addr);
serv_addr.sin_port = htons(port);
serv_sockfd = Socket(AF_INET, SOCK_STREAM, 0);
if(serv_sockfd > 0 )
isConnected = tcpConnect(serv_sockfd,serv_addr,port);
char status[1024];
int errcode = EXIT_SUCCESS;
memset(status,0,sizeof(status));
if(isConnected)
{
strcpy(status,"STATUS \t: Connected to Server...");
//write_pipe(pfd,status,strlen(status));
}
else
{
strcpy(status,"STATUS \t: ");
strcat(status,strerror(errno));
//printf("%s\n",status);
write_pipe(pfd,status,strlen(status));
}
int l=0;
struct timeval timeout;
fd_set master_fds, curr_fds;
int maxfd;
int ready_fd_count =0;
int i=0;
printf("-----------------------------------------------------------------------\n ECHO MSG \t: ");
char back_buff[1024];
memset(back_buff,0,sizeof(back_buff));
do
{
FD_ZERO(&master_fds);
maxfd = serv_sockfd+1;
FD_SET(fileno(stdin),&master_fds);
FD_SET(serv_sockfd,&master_fds);
fflush(stdout);
fflush(stdout);
memset(msg,0,sizeof(msg));
memset(buff,0,sizeof(buff));
rc = select(maxfd,&master_fds,NULL,NULL,NULL);
if(rc < 0)
{
perror("select() failed");
break;
}
if( rc == 0)
{
printf("SELECT TIMED OUT\n");
break;
}
for(i=0;i<maxfd;i++)
{
if(FD_ISSET(i,&master_fds))
{
if(i==fileno(stdin))
{
memset(msg,0,sizeof(msg));
fgets(msg, sizeof(msg),stdin);
strcpy(back_buff,msg);
l = strlen(msg);
msg[l] = '\n';
if((l=writen(serv_sockfd,msg,l)) <0)
{
//send to parent that the echo request was sent to server.
memset(status,0,sizeof(status));
strcpy(status,"ERROR \t: Write to Echo Server Failed");
//printf("%s\n",status);
isConnected = false;
shutdown(serv_sockfd,2);
close(serv_sockfd);
rc = write_pipe(pfd,status,sizeof(buff));
if(rc == -1)
printf("PIPE CLOSED. I could be an orphan process now.. :(");
break;
}
}
if(i==serv_sockfd)
{
memset(buff,0,sizeof(buff));
if((rc=read(serv_sockfd,buff,sizeof(buff)))<0)
{
//send to parent that echo server responded back.
memset(status,0,sizeof(status));
strcpy(status,"ERROR \t: Read from Echo Server Failed");
//rc = write_pipe(pfd,status,sizeof(status));
shutdown(serv_sockfd,2);
close(serv_sockfd);
isConnected = false;
break;
//puts(buff);
}
else
{
//printf("LOG : read %d bytes from server \n",rc);
if(rc == 0)
{
if(errno == EINTR)
{
printf("STATUS \t: EINTR\n");
continue;
}
else
{
isConnected = false;
memset(status,0,sizeof(status));
strcpy(status,"STATUS \t: ECHO SERVER IS DOWN");
rc = write_pipe(pfd,status,strlen(status));
break;
}
}
printf("Echo Response \t: %s",buff);
printf("-----------------------------------------------------------------------\nECHO MSG \t: ");
fflush(stdout);
fflush(stdout);
memset(status,0,sizeof(status));
if(strcmp(back_buff,buff) == 0)
{
strcpy(status,"STATUS \t: ECHO SERVER WORKS PROPERLY");
rc = write_pipe(pfd,status,strlen(status));
//printf("%s\n",status);
}
else
{
strcpy(status,"STATUS \t: ECHO SERVER IS ERRORNEOUS");
rc = write_pipe(pfd,status,strlen(status));
//printf("%s\n",status);
//printf("SENT : %s\n RECVD :%s\n",back_buff,buff);
errcode = EXIT_FAILURE;
break;
}
memset(back_buff,0,sizeof(back_buff));
}
}
}
}
}while(isConnected);
printf("I am done\n");
shutdown(serv_sockfd,2);
close(serv_sockfd);
exit(-1);
}
error_t socketConnect(Socket *socket, const IpAddr *remoteIpAddr, uint16_t remotePort)
{
error_t error;
//Check input parameters
if(!socket || !remoteIpAddr)
return ERROR_INVALID_PARAMETER;
#if (TCP_SUPPORT == ENABLED)
//Connection-oriented socket?
if(socket->type == SOCKET_TYPE_STREAM)
{
//Save port number and IP address of the remote host
socket->remoteIpAddr = *remoteIpAddr;
socket->remotePort = remotePort;
//Select the source address and the relevant network interface
//to use when establishing the connection
error = ipSelectSourceAddr(&socket->interface,
&socket->remoteIpAddr, &socket->localIpAddr);
//Any error to report?
if(error) return error;
//Make sure the source address is valid
if(ipIsUnspecifiedAddr(&socket->localIpAddr))
return ERROR_NOT_CONFIGURED;
//Enter critical section
osAcquireMutex(&socketMutex);
//Establish TCP connection
error = tcpConnect(socket);
//Leave critical section
osReleaseMutex(&socketMutex);
}
else
#endif
//Connectionless socket?
if(socket->type == SOCKET_TYPE_DGRAM)
{
//Save port number and IP address of the remote host
socket->remoteIpAddr = *remoteIpAddr;
socket->remotePort = remotePort;
//No error to report
error = NO_ERROR;
}
//Raw socket?
else if(socket->type == SOCKET_TYPE_RAW_IP)
{
//Save the IP address of the remote host
socket->remoteIpAddr = *remoteIpAddr;
//No error to report
error = NO_ERROR;
}
//Socket type not supported...
else
{
//Invalid socket type
error = ERROR_INVALID_SOCKET;
}
//Return status code
return error;
}
int main(int argc, char **argv)
{
int listenfd, connfd, n;
EL *el;
CF *conf;
char *opName[] = {
"Listen",
"ServerPath",
"ClusterManagerName",
"ClusterManagerPort"};
char *ptr;
socklen_t addrlen;
char BUFF[MAXLINE];
struct sockaddr_storage cliaddr;
if (argc > 2)
err_quit("usage: node [path to config file] <--help>\n");
if (argc == 2 && strcmp(argv[1],"--help") != 0)
conf = cfileInit(argv[1],opName);
else if (argc == 1)
conf = cfileInit(DB_CONF,opName);
connfd = tcpConnect(
getOption(conf,"ClusterManagerName"),
getOption(conf,"ClusterManagerPort"));
if (connfd < 0)
err_quit("error for connecting cluster manager.\n");
strcpy(BUFF,"REG ");
getExternalIp(BUFF + 4);
strcat(BUFF,"\r\n");
write(connfd,BUFF,strlen(BUFF));
if ((n = read(connfd,BUFF,MAXLINE)) > 0) {
BUFF[n] = '\0';
if (strcmp(BUFF,"REG ERR\r\n") == 0)
err_quit("error for registering node in cluster");
} else
err_quit("error for registering node in cluster");
close(connfd);
if ((ptr = getOption(conf,"Listen")) != NULL)
listenfd =
tcpListen(getOption(conf,"ServerName"),ptr,&addrlen);
else
err_quit("error for opening listen port.\n");
if ((el = el_open()) == NULL)
err_quit("node error for creating epoll.\n");
el_addFileEvent(el,listenfd,AE_READABLE,sendRequesData,(void *)conf);
el_start(el,AE_BLOCK);
el_close(el);
}
int
fsm(isc_opt_t *op)
{
state_t state;
isess_t *sess;
if((sess = calloc(1, sizeof(isess_t))) == NULL) {
// boy, is this a bad start ...
fprintf(stderr, "no memory!\n");
return -1;
}
state = S1;
sess->op = op;
sess->fd = -1;
sess->soc = -1;
sess->target.address = strdup(op->targetAddress);
sess->target.port = op->port;
sess->target.pgt = op->targetPortalGroupTag;
sess->flags = SESS_INITIALLOGIN | SESS_INITIALLOGIN1;
do {
switch(state) {
case S1:
switch(tcpConnect(sess)) {
case T1: state = S2; break;
default: state = S8; break;
}
break;
case S2:
switch(startSession(sess)) {
case T2: state = S1; break;
case T4: state = S4; break;
default: state = S8; break;
}
break;
case S4:
switch(doLogin(sess)) {
case T7: state = S1; break;
case T5: state = S5; break;
default: state = S8; break;
}
break;
case S5:
switch(supervise(sess)) {
case T8: state = S1; break;
case T9: state = S6; break;
case T11: state = S7; break;
case T15: state = S8; break;
default: state = S8; break;
}
break;
case S6:
switch(startLogout(sess)) {
case T13: state = S1; break;
case T14: state = S6; break;
case T16: state = S8; break;
default: state = S8; break;
}
break;
case S7:
switch(inLogout(sess)) {
case T18: state = S1; break;
case T10: state = S6; break;
case T12: state = S7; break;
case T16: state = S8; break;
default: state = S8; break;
}
break;
case S8:
// maybe do some clean up?
syslog(LOG_INFO, "terminated");
return 0;
}
} while(1);
}
TcpClient::TcpClient(QString host, quint16 port)
{
this->host = host.length() > 0 ? host : "127.0.0.1";
this->port = port > 0 ? port : 27015;
tcpConnect();
}
int HttpClient::requestContent(Url &url, string &contentStr, int expectContentLength) {
// construct a request
string requestStr;
string path = url.getPath();
if (path.empty())
path = "/";
requestStr = "GET " + path + " HTTP/1.0\r\nHost: " + url.getHost()
+ "\r\nUser-Agent: openSE/1.0 (Ubuntu11.04)\r\nAccept-Language: zh,en-us\r\nAccept-Charset: gb2312,utf-8\r\nConnection: Keep-Alive\r\n\r\n";
cout << "requestStr:\n" << requestStr << endl;
// send request:
if (url.getHost() != _preHost) {
if (_preSockFd != -1) {
closesocket(_preSockFd);
_preSockFd = -1;
}
}
int sockFd;
bool sendSuccess = false;
// try to use previous connection
if (_preSockFd != -1) {
sockFd = _preSockFd;
if (rio_writen(sockFd, requestStr.c_str(), requestStr.size()) == -1) {
cerr << "use previous connection:rio_writen error !" << endl;
closesocket(_preSockFd);
_preSockFd = -1;
} else
sendSuccess = true;
}
if (!sendSuccess) {
// try to creat a new connection
sockFd = tcpConnect(url.getIp(), url.getPort());
if (sockFd == -1) {
cerr << "tcpConnect error" << endl;
return -1;
}
// try to use new connection
if (rio_writen(sockFd, requestStr.c_str(), requestStr.size()) == -1) {
cerr << "rio_writen error for requestStr:" << requestStr << endl;
closesocket(sockFd);
return -1;
}
}
//// receive http header
//string headerStr;
//headerStr.reserve(1024);
//if(receiveHeader(sockFd, headerStr, DEFAULT_TIMEOUT_SECONDS) <= 0){
// cerr << "receiveHeader error" << endl;
// closesocket(sockFd);
// _preSockFd = -1;
// return -1;
// }
//cout << "headerStr:\n" << headerStr << endl;
//// parser http header
//httpHeader.setHeaderStr(headerStr);
//// check StatusCode
//int stausCode = httpHeader.getStatusCode();
//if(stausCode == -1){
// cerr << "not find status code in httpHeader: " << httpHeader.getHeaderStr() << endl;
// }
//if(stausCode == 301 || stausCode == 302){
// closesocket(sockFd);
// _preSockFd = -1;
// string locationUrlStr = httpHeader.getLocation();
// if(locationUrlStr.empty()){
// cerr << "error location in httpHeader: " << httpHeader.getHeaderStr() << endl;
// }
// //locationStr = location;
// Url locationUrl(locationUrlStr);
// return requestWebPage(locationUrl, httpHeader, httpContent);
// }
//if(stausCode < 200 || stausCode > 299){
// closesocket(sockFd);
// _preSockFd = -1;
// cerr << "status code beyond [200-300) in httpHeader: " << httpHeader.getHeaderStr() << endl;
// return -1;
// }
//// check content type
//string contentType = httpHeader.getContentType();
//if(contentType.find("image") != string::npos){
// closesocket(sockFd);
// _preSockFd = -1;
// cerr << "contentType is image in httpHeader: " << httpHeader.getHeaderStr() << endl;
// return -1;
// }
//// check ContentLength
//int contentLength = httpHeader.getContentLength();
//if(contentLength == -1){
// //cerr << "contentLength is not finded in httpHeader: " << httpHeader.getHeaderStr() << endl;
// contentLength = MAX_HTTPCONTENT_SIZE/10;
// }
//if(contentLength == 0){
// closesocket(sockFd);
// _preSockFd = -1;
// cerr << "contentLength is 0 in httpHeader: " << httpHeader.getHeaderStr() << endl;
// return -1;
// }
//if(contentLength > MAX_HTTPCONTENT_SIZE){
// closesocket(sockFd);
// _preSockFd = -1;
// cerr << "contentLength > MAX_HTTPCONTENT_SIZE in httpHeader: "
// << httpHeader.getHeaderStr() << endl;
// return -1;
// }
// receive content
if (receiveContent(sockFd, expectContentLength, contentStr, DEFAULT_TIMEOUT_SECONDS)
== -1) {
closesocket(sockFd);
_preSockFd = -1;
cerr << "receiveContent error for url: " << url.getUrlStr() << endl;
cout << contentStr << endl;
return -1;
} else
_preSockFd = sockFd;
cout << "contentStr:\n" << contentStr << endl;
// cout << "content finished,url is:"<<url.getUrlStr()<<endl;
// set http content
return 0;
}
