int TCPIPserver::read(int conn, char* buffer, size_t len){
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::read()");
return 0;
}
if (timeout==0) return recv(connections[conn].fd, buffer, len, 0);
int n, rv;
fd_set readfds;
struct timeval tv;
FD_ZERO(&readfds);
FD_SET(connections[conn].fd, &readfds);
n=connections[conn].fd+1;
tv.tv_sec=timeout;
rv=select(n, &readfds, NULL, NULL, &tv);
//std::cout<<rv<<std::endl;
if (rv==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read()");
return 0;
} else if (rv==0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read()");
return 0;
} else {
if (FD_ISSET(connections[conn].fd, &readfds)) {
return recv(connections[conn].fd, buffer, len, 0);
} else {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read()");
return 0;
}
}
}
std::string TCPIPserver::read_str_until(int conn, char endchar){
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::read_str_until()");
return "";
}
clock_t start;//, end;
double cpu_time_used;
char d;
int count=0;
std::string answer="";
int n, rv;
fd_set readfds;
struct timeval tv;
if (timeout==0) {
do {
count = recv(connections[conn].fd, &d, 1, 0);
if ((count>0)&&(d!=endchar)) answer+=d;
} while ((count > 0)&&(d!=endchar));
return answer;
}
start = clock();
cpu_time_used=0;
do {
FD_ZERO(&readfds);
FD_SET(connections[conn].fd, &readfds);
n=connections[conn].fd+1;
tv.tv_sec=timeout;
rv=select(n, &readfds, NULL, NULL, &tv);
//std::cout<<rv<<std::endl;
if (rv==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
} else if (rv==0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
} else {
if (FD_ISSET(connections[conn].fd, &readfds)) {
count=recv(connections[conn].fd, &d, 1, 0);
} else {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
}
}
if ((count>0)&&(d!=endchar)) answer+=d;
cpu_time_used = ((double) (clock() - start)) / CLOCKS_PER_SEC;
} while ((count > 0)&&(d!=endchar)&&(cpu_time_used<(double)timeout));
if (cpu_time_used<(double)timeout) return answer;
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read_str_until()");
return "";
}
std::string TCPIPserver::get_version() {
std::string data="";
#ifdef __WINDOWS__
data+="driver: WinSock32";
data+=" supports ver"+__inttostr(wsaData.wVersion & 0xFF)+"."+__inttostr((wsaData.wVersion & 0xFF00)>>8);
data+=" to ver"+__inttostr(wsaData.wHighVersion & 0xFF)+"."+__inttostr((wsaData.wHighVersion & 0xFF00)>>8)+"\n";
data+=__format("description: %s\n", wsaData.szDescription);
data+=__format("system status: %s\n", wsaData.szSystemStatus);
#else
data+="driver: Unix Socket Library 'sys/socket.h'\n";
#endif
return data;
};
std::string TCPIPserver::get_client_name(int conn) {
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::get_client_name()");
return "";
}
return __format("%s", inet_ntoa(connections[conn].client.sin_addr));
};
void TCPIPserver::write(int conn, char* buffer, size_t len){
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::write()");
return ;
}
/*if (send( connections[conn].fd, buffer, len, 0)==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SENDFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SENDFAIL_NUM), strerror(errno)), "TCPIPserver::write()");
};*/
size_t total=0; // what has been send so far
int bytesleft=len; // what is left to send
int tobesent=mmin(chunksize, bytesleft);
int n, m, rv;
fd_set writefds;
struct timeval tv;
while (total<len) {
tobesent=mmin(chunksize, bytesleft);
if (timeout>0) {
FD_ZERO(&writefds);
FD_SET(connections[conn].fd, &writefds);
m=connections[conn].fd+1;
tv.tv_sec=timeout;
rv=select(m, NULL, &writefds, NULL, &tv);
if (rv==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::write()");
return;
} else if (rv==0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::write()");
return;
} else {
if (FD_ISSET(connections[conn].fd, &writefds)) {
n = send(connections[conn].fd, buffer+total, tobesent, 0);
} else {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::write()");
return;
}
}
} else {
n = send(connections[conn].fd, buffer+total, tobesent, 0);
}
if (n==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SENDFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SENDFAIL_NUM), strerror(errno)), "TCPIPserver::write()");
return;
}
total+=n;
bytesleft-=n;
}
}
char TCPIPserver::read_char(int conn){
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::read_char()");
return 0;
}
char d;
int count=0;
int n, rv;
fd_set readfds;
struct timeval tv;
if (timeout==0) {
while (count<1) {
count=recv(connections[conn].fd, &d, 1, 0);
}
return d;
}
//std::cout<<"reading one char ... ";
FD_ZERO(&readfds);
FD_SET(connections[conn].fd, &readfds);
n=connections[conn].fd+1;
tv.tv_sec=timeout;
rv=select(n, &readfds, NULL, NULL, &tv);
if (rv==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return 0;
} else if (rv==0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read_char()");
return 0;
} else {
if (FD_ISSET(connections[conn].fd, &readfds)) {
count=recv(connections[conn].fd, &d, 1, 0);
//std::cout<<chartostr(d)<<std::endl;
if (count>0) return d;
} else {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return 0;
}
}
return 0;
}
int TCPIPserver::accept_connection(){
int num=get_new_connection_num();
int len = sizeof(connections[num].client);
connections[num].fd = accept(sockfd, (struct sockaddr*)&connections[num].client, &len);
if (connections[num].fd < 0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_ACCEPTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_ACCEPTFAIL_NUM), strerror(errno)), "TCPIPserver::accept_connection()");
return 0;
return 0;
}
return num;
}
void TCPIPserver::open_socket(){
// generate a new TCP/IP stream socket
sockfd=socket(PF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SOCKETFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SOCKETFAIL_NUM), strerror(errno)), "TCPIPserver::open_socket()");
return;
}
memset(server.sin_zero, '\0', sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(port);
server.sin_addr.s_addr = htonl( INADDR_ANY);
if (bind(sockfd, (struct sockaddr*)&server, sizeof(server))==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_BINDFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_BINDFAIL_NUM), strerror(errno)), "TCPIPserver::open_socket()");
return;
}
if (listen(sockfd, backlog) == -1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_LISTENFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_LISTENFAIL_NUM), strerror(errno)), "TCPIPserver::open_socket()");
return;
}
}
static void pformat(const char *const fmt, va_list va)
{
__format(fmt, va, printf_handler, NULL);
}
std::string TCPIPserver::read_str_until(int conn, const std::string& endstring){
if (!connection_exists(conn)) {
SEQUENCER_ERRORN(SEQUENCER_NETERROR_CRANGE_NUM, "TCPIPserver::read_str_until()");
return "";
}
clock_t start;//, end;
double cpu_time_used;
char d;
int count=0;
std::string answer="";
int n, rv;
fd_set readfds;
struct timeval tv;
bool done=false;
if (timeout==0) {
do {
count = recv(connections[conn].fd, &d, 1, 0);
if ((count>0)) answer+=d;
done=false;
if (answer.size()>=endstring.size()) {
done=true;
for (size_t i=0; i<endstring.size(); i++) {
if (answer[answer.size()-endstring.size()+i]!=endstring[i]) {
done=false;
break;
}
}
}
} while ((count > 0)&&(!done));
std::string a;
for (size_t i=0; i<answer.size()-endstring.size(); i++) {
a=a+answer[i];
}
return a;
}
start = clock();
cpu_time_used=0;
do {
FD_ZERO(&readfds);
FD_SET(connections[conn].fd, &readfds);
n=connections[conn].fd+1;
tv.tv_sec=timeout;
rv=select(n, &readfds, NULL, NULL, &tv);
//std::cout<<rv<<std::endl;
if (rv==-1) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
} else if (rv==0) {
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
} else {
if (FD_ISSET(connections[conn].fd, &readfds)) {
count=recv(connections[conn].fd, &d, 1, 0);
} else {
SEQUENCER_ERROR(SEQUENCER_NETERROR_SELECTFAIL_NUM, __format(get_errormessage(SEQUENCER_NETERROR_SELECTFAIL_NUM), strerror(errno)), "TCPIPserver::read_char()");
return "";
}
}
if ((count>0)) answer+=d;
done=false;
if (answer.size()>=endstring.size()) {
done=true;
for (size_t i=0; i<endstring.size(); i++) {
if (answer[answer.size()-endstring.size()+i]!=endstring[i]) {
done=false;
break;
}
}
}
cpu_time_used = ((double) (clock() - start)) / CLOCKS_PER_SEC;
} while ((count > 0)&&(!done)&&(cpu_time_used<(double)timeout));
if (cpu_time_used<(double)timeout) {
std::string a;
for (size_t i=0; i<answer.size()-endstring.size(); i++) {
a=a+answer[i];
}
return a;
}
SEQUENCER_ERROR(SEQUENCER_NETERROR_TIMEOUT_NUM, __format(get_errormessage(SEQUENCER_NETERROR_TIMEOUT_NUM), strerror(errno)), "TCPIPserver::read_str_until()");
return "";
}
std::string __inttostr(int i) {
return __format("%d", i);
}
/*
* gg_session_handler_search50()
*
* zajmuje siê obs³ug± wyniku przeszukiwania katalogu publicznego.
*
* - s - sesja
* - e - opis zdarzenia
*/
void gg_session_handler_search50(session_t *s, struct gg_event *e)
{
gg_private_t *g = session_private_get(s);
gg_pubdir50_t res = e->event.pubdir50;
int i, count, all = 0;
list_t l;
uin_t last_uin = 0;
if (!g)
return;
if ((count = gg_pubdir50_count(res)) < 1) {
print("search_not_found");
return;
}
debug_function("gg_session_handler_search50() handle_search50, count = %d\n", gg_pubdir50_count(res));
for (l = g->searches; l; l = l->next) {
gg_pubdir50_t req = l->data;
if (gg_pubdir50_seq(req) == gg_pubdir50_seq(res)) {
all = 1;
break;
}
}
for (i = 0; i < count; i++) {
const char *uin = gg_pubdir50_get(res, i, "fmnumber");
const char *__firstname = gg_pubdir50_get(res, i, "firstname");
const char *__lastname = gg_pubdir50_get(res, i, "lastname");
const char *__nickname = gg_pubdir50_get(res, i, "nickname");
const char *__fmstatus = gg_pubdir50_get(res, i, "fmstatus");
const char *__birthyear = gg_pubdir50_get(res, i, "birthyear");
const char *__city = gg_pubdir50_get(res, i, "city");
char *firstname = gg_to_core_dup(s, __firstname);
char *lastname = gg_to_core_dup(s, __lastname);
char *nickname = gg_to_core_dup(s, __nickname);
char *city = gg_to_core_dup(s, __city);
int status = (__fmstatus) ? atoi(__fmstatus) : GG_STATUS_NOT_AVAIL;
const char *birthyear = (__birthyear && xstrcmp(__birthyear, "0")) ? __birthyear : NULL;
char *name, *active, *gender;
const char *target = NULL;
if (count == 1 && !all) {
xfree(last_search_first_name);
xfree(last_search_last_name);
xfree(last_search_nickname);
xfree(last_search_uid);
last_search_first_name = xstrdup(firstname);
last_search_last_name = xstrdup(lastname);
last_search_nickname = xstrdup(nickname);
last_search_uid = saprintf("gg:%s", uin);
}
name = saprintf(
("%s %s"),
firstname ? firstname : (""),
lastname ? lastname : (""));
#define __format(x) ((count == 1 && !all) ? "search_results_single" x : "search_results_multi" x)
{
const char *fvalue;
switch (status) {
case GG_STATUS_AVAIL:
case GG_STATUS_AVAIL_DESCR:
fvalue = format_find(__format("_avail"));
break;
case GG_STATUS_BUSY:
case GG_STATUS_BUSY_DESCR:
fvalue = format_find(__format("_away"));
break;
default:
fvalue = format_find(__format("_notavail"));
}
active = format_string(fvalue, (__firstname) ? __firstname : nickname);
}
gender = format_string(format_find(__format("_unknown")), "");
/* XXX: why do we _exactly_ use it here? can't we just always
* define target and thus display result in right conversation window? */
for (l = autofinds; l; l = l->next) {
char *d = (char *) l->data;
if (!xstrcasecmp(d + 3, uin)) {
target = d;
break;
}
}
print_info(target, s, __format(""),
uin ? uin : ("?"), name,
nickname ? nickname : (""),
city ? city : (""),
birthyear ? birthyear : ("-"),
gender, active);
#undef __format
xfree(name);
xfree(active);
xfree(gender);
xfree(firstname);
xfree(lastname);
xfree(nickname);
xfree(city);
last_uin = atoi(uin);
}
/* je¶li mieli¶my ,,/find --all'', szukamy dalej */
for (l = g->searches; l; l = l->next) {
gg_pubdir50_t req = l->data;
uin_t next;
if (gg_pubdir50_seq(req) != gg_pubdir50_seq(res))
continue;
/* nie ma dalszych? to dziêkujemy */
if (!(next = gg_pubdir50_next(res)) || !g->sess || next <= last_uin) {
list_remove(&g->searches, req, 0);
gg_pubdir50_free(req);
break;
}
gg_pubdir50_add(req, GG_PUBDIR50_START, ekg_itoa(next));
gg_pubdir50(g->sess, req);
break;
}
}
