static int ioctl_set_pvc(ITF *itf,uint32_t ip,struct sockaddr_atmpvc *addr,
const struct atm_qos *qos,int sndbuf,int flags)
{
ENTRY *entry;
VCC *vcc;
int fd,result;
if (lookup_ip(itf,ip)) return -EEXIST;
if ((fd = connect_vcc((struct sockaddr *) addr,qos,sndbuf,0)) < 0)
return fd;
if ((result = set_ip(fd,ip)) < 0) {
do_close(fd);
return result;
}
if (flags & ATF_NULL) {
if ((result = set_encap(fd,0)) < 0) return result;
flags |= ATF_PERM;
}
entry = alloc_entry(0);
entry->state = as_valid;
entry->ip = ip;
entry->qos = *qos;
entry->sndbuf = sndbuf;
entry->flags = flags;
entry->itf = itf;
vcc = alloc_t(VCC);
vcc->active = 1;
vcc->connecting = 0;
vcc->fd = fd;
vcc->entry = entry;
if (!(flags & ATF_PERM)) START_TIMER(entry,CREVAL);
Q_INSERT_HEAD(entry->vccs,vcc);
Q_INSERT_HEAD(itf->table,entry);
return 0;
}
int get_ip_from_server(int net_fd, char *devname)
{
char *buffer;
// Get IP Address from server
buffer = malloc(100) ;
struct ip_header *iphdr = (struct ip_header*)buffer ;
memset(buffer,0,100) ;
iphdr->vers = 0x45 ;
iphdr->ip_header_len = 20 ;
iphdr->ttl = 64;
if(cwrite(net_fd, buffer, 20) <= 0)
{
printf("error: write failed while getting IP address from server\n");
exit(1);
}
cread(net_fd, buffer, 100) ;
printf("Got IP response: %08x\n", ntohl(iphdr->dest_ip)) ;
set_ip(devname, ntohl(iphdr->dest_ip), 0xffff0000);
// Set the interface address.
free(buffer) ;
return 0;
}
static int kplib_ipof(ktap_state_t *ks)
{
unsigned long addr = kp_arg_checknumber(ks, 1);
set_ip(ks->top++, addr);
return 1;
}
bool cTextField::handleClick(location clickLoc) {
if(!haveFocus && parent && !parent->setFocus(this)) return true;
haveFocus = true;
redraw(); // This ensures the snippets array is populated.
std::string contents = getText();
bool hadSelection = selectionPoint != insertionPoint;
bool is_double = click_timer.getElapsedTime().asMilliseconds() < 500;
click_timer.restart();
bool is_shift = sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) || sf::Keyboard::isKeyPressed(sf::Keyboard::RShift);
set_ip(clickLoc, is_shift ? &cTextField::selectionPoint : &cTextField::insertionPoint);
if(!is_shift) selectionPoint = insertionPoint;
if(is_double && !is_shift && !hadSelection) {
cKey key = {true, key_word_right, mod_none};
if(insertionPoint < contents.size() && contents[insertionPoint] != ' ')
handleInput(key);
key.k = key_word_left;
key.mod += mod_shift;
handleInput(key);
}
bool done = false;
sf::Event e;
int initial_ip = insertionPoint, initial_sp = selectionPoint;
while(!done) {
redraw();
if(!inWindow->pollEvent(e)) continue;
if(e.type == sf::Event::MouseButtonReleased){
done = true;
} else if(e.type == sf::Event::MouseMoved){
restore_cursor();
location newLoc(e.mouseMove.x, e.mouseMove.y);
set_ip(newLoc, &cTextField::selectionPoint);
if(is_double) {
if(selectionPoint > initial_ip) {
insertionPoint = initial_sp;
while(selectionPoint < contents.length() && contents[selectionPoint] != ' ')
selectionPoint++;
} else {
insertionPoint = initial_ip;
while(selectionPoint > 0 && contents[selectionPoint - 1] != ' ')
selectionPoint--;
}
}
}
}
redraw();
return true;
}
void jmp_op(enum opcode opcode, OPERAND **operands)
{
int addr = get_val(operands[0]) - code_offset;
int cmp = cpu->registers[RESERVED_REG(REG_CMP)];
print_dbg("jmp_op(): addr = %d code_offset = %d\n", addr, code_offset);
addr -= sizeof(int64_t); // Account for += sizeof(int64_t) after eval() in cycle()
switch(opcode) {
case JMP:
set_ip(addr);
break;
case JE:
if(cmp == 0) set_ip(addr);
break;
case JNE:
if(cmp != 0) set_ip(addr);
break;
case JL:
if(cmp == 2) set_ip(addr);
break;
case JLE:
if(cmp == 0 || cmp == 2) set_ip(addr);
break;
case JG:
if(cmp == 1) set_ip(addr);
break;
case JGE:
if(cmp == 0 || cmp == 1) set_ip(addr);
break;
}
}
int set_localaddr (char *word, char *value, int context, void *item)
{
struct lac *l;
struct lns *n;
switch (context & ~CONTEXT_DEFAULT)
{
case CONTEXT_LAC:
l = (struct lac *) item;
return set_ip (word, value, &(l->localaddr));
case CONTEXT_LNS:
n = (struct lns *) item;
return set_ip (word, value, &(n->localaddr));
default:
snprintf (filerr, sizeof (filerr), "'%s' not valid in this context\n",
word);
return -1;
}
return 0;
}
void Port::MergeFrom(const Port& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_port_num()) {
set_port_num(from.port_num());
}
if (from.has_ip()) {
set_ip(from.ip());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
static void timeout(ENTRY *entry)
{
VCC *vcc,*next;
entry->timer = NULL;
switch (entry->state) {
case as_resolv:
send_notifications(entry,0);
if ((entry->flags & ATF_ARPSRV) && !entry->vccs) {
if (entry->itf) want_arp_srv(entry->itf);
break;
}
if (!entry->vccs && !(entry->flags & (ATF_PERM | ATF_ARPSRV)))
discard_entry(entry);
else entry->state = as_invalid;
break;
case as_valid:
if (!entry->vccs && !(entry->flags & (ATF_PERM | ATF_ARPSRV)) &&
entry->itf->arp_srv) {
discard_entry(entry);
break;
}
for (vcc = entry->vccs; vcc; vcc = next) {
next = vcc->next;
if (!vcc->connecting)
if (set_ip(vcc->fd,0) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip(0): %s",
strerror(errno));
disconnect_vcc(vcc);
}
}
if (entry->svc && entry->itf->arp_srv &&
!(entry->flags & ATF_ARPSRV)) revalidate(entry);
else {
inarp_request(entry);
START_TIMER(entry,REPLY);
entry->state = as_invalid;
}
break;
case as_invalid:
if (!entry->svc) {
inarp_request(entry);
START_TIMER(entry,REPLY);
}
else if ((!entry->itf || !entry->itf->arp_srv) &&
!(entry->flags & ATF_PERM)) discard_entry(entry);
break;
default:
diag(COMPONENT,DIAG_FATAL,"timed out in state %s",
entry_state_name[entry->state]);
}
}
static void fapp_set_ip(fnet_shell_desc_t desc, char *value, void (*set_ip)( fnet_netif_desc_t netif_desc, fnet_ip4_addr_t ipaddr ) )
{
fnet_ip4_addr_t addr;
if(fnet_inet_aton(value, (struct in_addr *) &addr) == FNET_OK)
{
set_ip(fapp_default_netif, addr);
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, value);
};
}
Connection::Connection(void) :
init_ok_(0),
last_recv_time_(time(NULL)),
last_send_time_(time(NULL)),
last_error_(0),
auto_release_(0),
state_(CLOSED),
default_event_handler_("ConnDefHandler"),
connection_manager_(NULL),
event_handler_(&default_event_handler_)
{
set_ip(0U);
set_port(0U);
set_protocol("tcp");
}
//initialize client parameters
int MATRIXClient::init(int num_tasks, int numSleep, ZHTClient &clientRet, int log, int index, int num_cores, int monitor_interval) {
//cout << "mc: prefix = " << prefix << " shared = " << shared << endl;
//client_id is the host name of the client
if(set_ip(client_id))
{
printf("Could not get the IP address of this machine!\n");
return -1;
}
total_num_tasks = num_tasks;
ncores = num_cores;
minterval = monitor_interval;
//total_submitted = num_tasks;
// string host("localhost");
selfindex = getSelfIndex(client_id, clientRet.memberList);
stringstream numSleep_ss, num_nodes_ss;
numSleep_ss << numSleep;
string suffix("_");
suffix.append(numSleep_ss.str());
suffix.append("_");
num_nodes_ss << clientRet.memberList.size();
suffix.append(num_nodes_ss.str());
cl_LOGGING = log;
stringstream index_ss;
index_ss << index;
if(cl_LOGGING) {
outputfile.append(prefix);
outputfile.append("client_log.txt");
outputfile.append(index_ss.str());
outputfile.append(suffix);
client_logfile.open(outputfile.c_str());
}
// if(index == 1){
// loadfile_name.append(prefix);
// loadfile_name.append("worker_load");
// loadfile_name.append(suffix);
// loadfile.open(loadfile_name.c_str(), ios_base::app);
// }
pthread_attr_init(&attr); // set thread detachstate attribute to DETACHED
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
return 0;
}
int set_listenaddr (char *word, char *value, int context, void *item)
{
switch (context & ~CONTEXT_DEFAULT)
{
case CONTEXT_GLOBAL:
#ifdef DEBUG_FILE
l2tp_log (LOG_DEBUG, "set_listenaddr: Setting listen address to %s\n",
value);
#endif
if (set_ip (word, value, &(((struct global *) item)->listenaddr)))
return -1;
break;
default:
snprintf (filerr, sizeof (filerr), "'%s' not valid in this context\n",
word);
return -1;
}
return 0;
}
void vcc_connected(VCC *vcc)
{
ENTRY *entry;
diag(COMPONENT,DIAG_DEBUG,"connected VCC 0x%p",vcc);
if (!vcc->connecting)
diag(COMPONENT,DIAG_FATAL,"non-connecting VCC connected");
vcc->connecting = 0;
if (vcc->entry->flags & ATF_ARPSRV)
for (entry = vcc->entry->itf->table; entry; entry = entry->next)
if (entry->state == as_resolv) {
START_TIMER(entry,REPLY);
arp_request(entry->itf,entry->ip);
}
inarp_request(vcc->entry);
if (vcc->entry->state == as_valid)
if (set_ip(vcc->fd,vcc->entry->ip) < 0) {
diag(COMPONENT,DIAG_ERROR,"can't set IP (%s)",strerror(errno));
disconnect_vcc(vcc);
}
}
rProtos::DeviceInfo *rEngine::populateDeviceInfo()
{
auto dev = new rProtos::DeviceInfo();
std::string macAddress, ip;
//do some linux stuff here!
if (!avahi::readServiceInfoFile("/etc/avahi/services/remotecontrol.service", *dev))
return 0;
netinfo::getIfInfo(macAddress, ip);
//read ip address
dev->set_ip(ip);
/* dev->set_ip("192.168.1.138");
dev->set_location("Bedroom");
dev->set_mac("de:ad:be:ef:ba:0d");
dev->set_id(0);
dev->set_name("Chromebox 1");
dev->set_mode("Steam");*/
return dev; //or null
}
MSNServerMessage::~MSNServerMessage()
{
QString msg = QString::fromUtf8(m_msg.c_str());
for (;!msg.isEmpty();){
QString line;
int n = msg.find("\r\n");
if (n >= 0){
line = msg.left(n);
msg = msg.mid(n + 2);
}else{
line = msg;
msg = "";
}
n = line.find(":");
if (n < 0)
continue;
QString key = line.left(n);
QString value = trim(line.mid(n + 1));
if (key == "ClientIP")
set_ip(&m_client->data.owner.IP, inet_addr(value.latin1()));
}
}
Connection::Connection(
const char* string_ip,
uint16_t port,
EventHandler* event_handler) :
init_ok_(0),
last_recv_time_(time(NULL)),
last_send_time_(time(NULL)),
last_error_(0),
auto_release_(0),
state_(CLOSED),
default_event_handler_("ConnDefHandler"),
connection_manager_(NULL)
{
set_ip(string_ip);
set_port(port);
set_protocol("tcp");
if (NULL == event_handler) {
event_handler_ = &default_event_handler_;
} else {
event_handler_ = event_handler;
}
}
int register_static_ip(int net_fd, int ip, char *devname)
{
char *buffer;
int nread;
// Static IP
buffer = malloc(100);
struct ip_header *iphdr = (struct ip_header*)buffer;
memset(buffer,0,100);
iphdr->vers = 0x45;
iphdr->ip_header_len = 20;
iphdr->ttl = 64;
iphdr->source_ip = ip;
if(cwrite(net_fd, buffer, 20) <= 0)
{
printf("error: write failed while requesting static IP address from server.\n");
exit(1);
}
nread = cread(net_fd, buffer, 100) ;
if(nread == 0)
{
// Connection closed while trying to assign a statick IP. This means that someone else already has that address.
fprintf(stderr, "ERROR: Requested static IP address already in use.\n");
exit(0);
}
set_ip(devname, ntohl(iphdr->dest_ip), 0xffff0000);
if(add_host_route(devname, (in_addr_t)ntohl(iphdr->dest_ip)) < 0)
printf("add_host_route returned\n");
// Set the interface address.
free(buffer) ;
return 0;
}
static void accept_new(void)
{
char buffer[MAX_ATM_ADDR_LEN+1];
struct sockaddr_atmsvc addr;
struct atm_qos qos;
ENTRY *entry;
VCC *vcc;
int fd,error;
socklen_t len,size;
len = sizeof(addr);
if ((fd = accept(incoming,(struct sockaddr *) &addr,&len)) < 0) {
error = errno;
diag(COMPONENT,DIAG_ERROR,"accept: %s",strerror(errno));
if (error == EUNATCH) {
diag(COMPONENT,DIAG_WARN,"disabling SVCs");
(void) close(incoming);
incoming = -1;
}
return;
}
/* the following code probably belongs to arp.c ... */
if (atm2text(buffer,MAX_ATM_ADDR_LEN+1,(struct sockaddr *) &addr,pretty) <
0) strcpy(buffer,"<atm2text error>");
diag(COMPONENT,DIAG_DEBUG,"Incoming call from %s",buffer);
size = sizeof(qos);
if (getsockopt(fd,SOL_ATM,SO_ATMQOS,&qos,&size) < 0)
diag(COMPONENT,DIAG_FATAL,"getsockopt SO_ATMQOS: %s",strerror(errno));
if (size != sizeof(qos))
diag(COMPONENT,DIAG_FATAL,"SO_ATMQOS: size %d != %d",size,sizeof(qos));
if (ioctl(fd,ATMARP_MKIP,qos.txtp.traffic_class == ATM_NONE ? 0 :
CLIP_DEFAULT_IDLETIMER) < 0) {
diag(COMPONENT,DIAG_ERROR,"ioctl ATMARP_MKIP: %s",strerror(errno));
(void) do_close(fd);
return;
}
vcc = alloc_t(VCC);
vcc->active = 0;
vcc->connecting = 0;
vcc->fd = fd;
if (qos.txtp.traffic_class == ATM_NONE) {
vcc->entry = NULL;
incoming_unidirectional(vcc);
Q_INSERT_HEAD(unidirectional_vccs,vcc);
return;
}
if (merge) {
ITF *itf;
for (itf = itfs; itf; itf = itf->next) {
entry = lookup_addr(itf,&addr);
if (entry) {
vcc->entry = entry;
Q_INSERT_HEAD(entry->vccs,vcc);
if (entry->state == as_valid) {
if (set_ip(vcc->fd,entry->ip) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip: %s",
strerror(errno));
disconnect_vcc(vcc);
}
else set_sndbuf(vcc);
}
return;
}
}
}
entry = alloc_entry(1);
entry->state = as_invalid;
entry->addr = alloc_t(struct sockaddr_atmsvc);
*entry->addr = addr;
entry->flags = ATF_PUBL;
Q_INSERT_HEAD(unknown_incoming,entry);
vcc->entry = entry;
Q_INSERT_HEAD(entry->vccs,vcc);
incoming_call(vcc);
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_PAUSE:
log(L_DEBUG, "Server pause");
m_bNoSend = true;
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_PAUSExACK);
m_socket->writeBuffer << ICQ_SNACxFAM_SERVICE
<< ICQ_SNACxFAM_LOCATION
<< ICQ_SNACxFAM_BUDDY
<< ICQ_SNACxFAM_MESSAGE
<< ICQ_SNACxFAM_BOS
<< ICQ_SNACxFAM_PING
<< ICQ_SNACxFAM_LISTS
<< ICQ_SNACxFAM_VARIOUS
<< ICQ_SNACxFAM_LOGIN;
sendPacket(true);
break;
case ICQ_SNACxSRV_RESUME:
log(L_DEBUG, "Server resume");
m_bNoSend = false;
processSendQueue();
break;
case ICQ_SNACxSRV_MIGRATE:{
log(L_DEBUG, "Server migrate");
m_bNoSend = true;
int i;
unsigned short cnt;
unsigned short fam[0x17];
m_socket->readBuffer >> cnt;
for (i = 0; i < cnt; i++) {
m_socket->readBuffer >> fam[i];
}
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_adr = tlv(0x05);
Tlv *tlv_cookie = tlv(0x06);
for (; i >= 0; i--) {
setServiceSocket(tlv_adr,tlv_cookie,fam[i]);
}
break;
}
case ICQ_SNACxSRV_RATExINFO:
case ICQ_SNACxSRV_RATExCHANGE:{
const char *msg_text = NULL;
unsigned short msg_code;
unsigned short class_id;
unsigned long window_size;
unsigned long clear_level;
unsigned long alert_level;
unsigned long limit_level;
unsigned long discon_level;
unsigned long current_level;
unsigned long max_level;
unsigned long last_level;
char current_state;
m_socket->readBuffer >> msg_code
>> class_id
>> window_size
>> clear_level
>> alert_level
>> limit_level
>> discon_level
>> current_level
>> max_level
>> last_level
>> current_state;
if (type == ICQ_SNACxSRV_RATExCHANGE){
switch (msg_code) {
case 0x0001:
msg_text = "Rate limits parameters changed";
break;
case 0x0002:
msg_text = "Rate limits warning";
break;
case 0x0003:
msg_text = "Rate limit hit";
break;
case 0x0004:
msg_text = "Rate limit clear";
break;
default:
msg_text = "Unknown";
}
log(L_DEBUG, msg_text);
}
log(L_DEBUG, "ws: %04X, cl %04X, al %04X, ll %04X, dl: %04X, cur %04X, ml %04X",
window_size,clear_level,alert_level,limit_level,discon_level,
current_level,max_level);
m_winSize = window_size;
m_maxLevel = max_level;
m_minLevel = alert_level;
m_curLevel = current_level;
m_lastSend = QDateTime::currentDateTime();
processSendQueue();
}
if (type != ICQ_SNACxSRV_RATExINFO)
break;
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket(true);
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket(true);
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
break;
case ICQ_SNACxSRV_MOTD:
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket(true);
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if ((unsigned)atol(screen.c_str()) != data.owner.Uin.value){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
log(L_DEBUG, "Name info");
break;
}
case ICQ_SNACxSRV_SERVICExRESP:{
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_id = tlv(0x0D);
if (!tlv_id){
log(L_WARN, "No service id in response");
break;
}
Tlv *tlv_adr = tlv(0x05);
Tlv *tlv_cookie = tlv(0x06);
setServiceSocket(tlv_adr,tlv_cookie,(unsigned short)(*tlv_id));
break;
}
case ICQ_SNACxSRV_READYxSERVER:
log(L_DEBUG, "Server ready");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_IMxICQ);
if (m_bAIM){
m_socket->writeBuffer
<< 0x00010003L
<< 0x00130003L
<< 0x00020001L
<< 0x00030001L
<< 0x00040001L
<< 0x00060001L
<< 0x00080001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}else{
m_socket->writeBuffer
<< 0x00010004L
<< 0x00130004L
<< 0x00020001L
<< 0x00030001L
<< 0x00150001L
<< 0x00040001L
<< 0x00060001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}
sendPacket(true);
break;
case ICQ_SNACxSRV_ERROR:
break;
case ICQ_SNACxSRV_EVIL:{
unsigned short level;
m_socket->readBuffer.unpack(level);
string from = m_socket->readBuffer.unpackScreen();
data.owner.WarningLevel.value = level;
QString f;
f = from.c_str();
if (f.isEmpty())
f = i18n("anonymous");
clientErrorData d;
d.client = this;
d.code = 0;
d.err_str = I18N_NOOP("You've been warned by %1");
d.args = strdup(f.utf8());
d.flags = ERR_INFO;
d.options = NULL;
d.id = CmdShowWarning;
Event e(EventClientError, &d);
e.process();
free(d.args);
break;
}
default:
log(L_WARN, "Unknown service family type %04X", type);
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_RATExCHANGE:
log(L_DEBUG, "Rate change");
if (m_nSendTimeout < 200){
m_nSendTimeout = m_nSendTimeout + 2;
if (m_sendTimer->isActive()){
m_sendTimer->stop();
m_sendTimer->start(m_nSendTimeout * 500);
}
}
break;
case ICQ_SNACxSRV_RATExINFO:
log(L_DEBUG, "Rate info");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket();
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket();
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
break;
case ICQ_SNACxSRV_MOTD:
log(L_DEBUG, "Motd");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket();
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
log(L_DEBUG, "Ack im icq");
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if (atol(screen.c_str()) != data.owner.Uin){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
log(L_DEBUG, "Name info");
break;
}
case ICQ_SNACxSRV_READYxSERVER:
log(L_DEBUG, "Server ready");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_IMxICQ);
m_socket->writeBuffer
<< 0x00010003L
<< 0x00130002L
<< 0x00020001L
<< 0x00030001L
<< 0x00150001L
<< 0x00040001L
<< 0x00060001L
<< 0x00090001L
<< 0x000a0001L
<< 0x000b0001L;
sendPacket();
break;
case ICQ_SNACxSRV_ERROR:
break;
default:
log(L_WARN, "Unknown service family type %04X", type);
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_PAUSE:
log(L_DEBUG, "Server pause");
/* we now shouldn't send any packets to the server ...
but I don't know how to solve this. Valdimir do you
have an idea? */
/* m_bDontSendPakets = true; */
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_PAUSExACK);
m_socket->writeBuffer << ICQ_SNACxFAM_SERVICE
<< ICQ_SNACxFAM_LOCATION
<< ICQ_SNACxFAM_BUDDY
<< ICQ_SNACxFAM_MESSAGE
<< ICQ_SNACxFAM_BOS
<< ICQ_SNACxFAM_PING
<< ICQ_SNACxFAM_LISTS
<< ICQ_SNACxFAM_VARIOUS
<< ICQ_SNACxFAM_LOGIN;
sendPacket();
break;
case ICQ_SNACxSRV_RESUME:
/* m_bDontSendPakets = true;
emit canSendPakets(); */
break;
case ICQ_SNACxSRV_MIGRATE:{
int i;
unsigned short cnt;
unsigned short fam[0x17];
m_socket->readBuffer >> cnt;
for (i = 0; i < cnt; i++) {
m_socket->readBuffer >> fam[i];
}
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_adr = tlv(0x05);
Tlv *tlv_cookie = tlv(0x06);
for (; i >= 0; i--) {
setServiceSocket(tlv_adr,tlv_cookie,fam[i]);
}
/* m_bDontSendPakets = true;
emit canSendPakets(); */
break;
}
case ICQ_SNACxSRV_RATExCHANGE:
log(L_DEBUG, "Rate change");
if (m_nSendTimeout < 200){
m_nSendTimeout = m_nSendTimeout + 2;
if (m_sendTimer->isActive()){
m_sendTimer->stop();
m_sendTimer->start(m_nSendTimeout * 500);
}
}
break;
case ICQ_SNACxSRV_RATExINFO:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket();
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket();
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
break;
case ICQ_SNACxSRV_MOTD:
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket();
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if ((unsigned)atol(screen.c_str()) != data.owner.Uin.value){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
log(L_DEBUG, "Name info");
break;
}
case ICQ_SNACxSRV_SERVICExRESP:{
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_id = tlv(0x0D);
if (!tlv_id){
log(L_WARN, "No service id in response");
break;
}
Tlv *tlv_adr = tlv(0x05);
Tlv *tlv_cookie = tlv(0x06);
setServiceSocket(tlv_adr,tlv_cookie,(unsigned short)(*tlv_id));
break;
}
case ICQ_SNACxSRV_READYxSERVER:
log(L_DEBUG, "Server ready");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_IMxICQ);
if (m_bAIM){
m_socket->writeBuffer
<< 0x00010003L
<< 0x00130003L
<< 0x00020001L
<< 0x00030001L
<< 0x00040001L
<< 0x00060001L
<< 0x00080001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}else{
m_socket->writeBuffer
<< 0x00010004L
<< 0x00130004L
<< 0x00020001L
<< 0x00030001L
<< 0x00150001L
<< 0x00040001L
<< 0x00060001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}
sendPacket();
break;
case ICQ_SNACxSRV_ERROR:
break;
case ICQ_SNACxSRV_EVIL:{
unsigned short level;
m_socket->readBuffer.unpack(level);
string from = m_socket->readBuffer.unpackScreen();
data.owner.WarningLevel.value = level;
QString f;
f = from.c_str();
if (f.isEmpty())
f = i18n("anonymous");
clientErrorData d;
d.client = this;
d.code = 0;
d.err_str = I18N_NOOP("You've been warned by %1");
d.args = strdup(f.utf8());
Event e(EventClientError, &d);
e.process();
free(d.args);
break;
}
default:
log(L_WARN, "Unknown service family type %04X", type);
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_RATExCHANGE:
log(L_DEBUG, "Rate change");
if (m_nSendTimeout < 200){
m_nSendTimeout = m_nSendTimeout + 2;
if (m_sendTimer->isActive()){
m_sendTimer->stop();
m_sendTimer->start(m_nSendTimeout * 500);
}
}
break;
case ICQ_SNACxSRV_RATExINFO:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket();
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket();
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
break;
case ICQ_SNACxSRV_MOTD:
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket();
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if ((unsigned)atol(screen.c_str()) != data.owner.Uin){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
log(L_DEBUG, "Name info");
break;
}
case ICQ_SNACxSRV_READYxSERVER:
log(L_DEBUG, "Server ready");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_IMxICQ);
if (m_bAIM){
m_socket->writeBuffer
<< 0x00010003L
<< 0x00130003L
<< 0x00020001L
<< 0x00030001L
<< 0x00040001L
<< 0x00060001L
<< 0x00080001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}else{
m_socket->writeBuffer
<< 0x00010004L
<< 0x00130004L
<< 0x00020001L
<< 0x00030001L
<< 0x00150001L
<< 0x00040001L
<< 0x00060001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}
sendPacket();
break;
case ICQ_SNACxSRV_ERROR:
break;
case ICQ_SNACxSRV_EVIL:{
unsigned short level;
m_socket->readBuffer.unpack(level);
string from = m_socket->readBuffer.unpackScreen();
data.owner.WarningLevel = level;
QString f;
f = from.c_str();
if (f.isEmpty())
f = i18n("anonymous");
clientErrorData d;
d.client = this;
d.code = 0;
d.err_str = I18N_NOOP("You've been warned by %1");
d.args = strdup(f.utf8());
Event e(EventClientError, &d);
e.process();
free(d.args);
break;
}
default:
log(L_WARN, "Unknown service family type %04X", type);
}
static int learn(VCC *vcc,uint32_t ip,struct sockaddr_atmsvc *addr)
{
ENTRY *entry;
ITF *itf;
VCC *walk,*next;
unsigned char *ipp;
int result = 0;
if (!ip) return 0;
ipp = (unsigned char *) &ip;
itf = lookup_itf_by_ip(ip);
if (!itf) {
diag(COMPONENT,DIAG_ERROR,"got unroutable IP address %d.%d.%d.%d",
ipp[0],ipp[1],ipp[2],ipp[3]);
return 0;
}
entry = lookup_ip(itf,ip);
assert(!vcc || vcc->entry);
/*
* If the entry on which we received the update isn't dangling but it
* doesn't correspond to the one with the address, ...
*/
if (entry && vcc && vcc->entry->itf && entry != vcc->entry) {
diag(COMPONENT,DIAG_DEBUG,"collision on %d.%d.%d.%d",ipp[0],ipp[1],
ipp[2],ipp[3]);
return 0;
}
/*
* If the entry on which we received the update is dangling and we found
* an entry that already describes that IP address, ...
*/
if (entry && vcc && !vcc->entry->itf) {
if (!entry->svc) {
diag(COMPONENT,DIAG_ERROR,"attempt to overwrite PVC for IP "
"%d.%d.%d.%d",ipp[0],ipp[1],ipp[2],ipp[3]);
return 0;
}
STOP_TIMER(vcc->entry);
Q_REMOVE(unknown_incoming,vcc->entry);
free(vcc->entry);
vcc->entry = entry;
Q_INSERT_HEAD(entry->vccs,vcc);
set_sndbuf(vcc);
entry->flags &= ~ATF_NOVC;
assert(!vcc->connecting);
if (set_ip(vcc->fd,ip) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip: %s",strerror(errno));
disconnect_vcc(vcc);
vcc = NULL;
result = -1;
}
}
/*
* If we still don't have an entry, we try to use the entry that already
* belongs to the VCC (InARP), or we create a new one (ARP).
*/
if (!entry) {
if (vcc) {
entry = vcc->entry;
if (!entry->itf) {
Q_REMOVE(unknown_incoming,entry);
entry->sndbuf = itf->sndbuf;
set_sndbuf(vcc);
}
else if (entry->ip && entry->ip != ip && (entry->flags & ATF_PERM)
&& !(entry->flags & ATF_ARPSRV)) {
diag(COMPONENT,DIAG_ERROR,"ignoring attempt to change IP "
"address of permanent entry (to %d.%d.%d.%d)",ipp[0],
ipp[1],ipp[2],ipp[3]);
return result;
}
}
else {
entry = alloc_entry(1);
entry->flags = ATF_PUBL;
}
}
if (!atmsvc_addr_in_use(*addr)) addr = NULL;
if (entry->addr && addr && (entry->flags & ATF_PERM) &&
!atm_equal((struct sockaddr *) entry->addr,(struct sockaddr *) addr,0,0))
{
diag(COMPONENT,DIAG_ERROR,"ignoring attempt to change ATM address of "
"permanent entry");
return result;
}
if (entry->state == as_valid && entry->ip == ip && (!addr || (entry->addr
&& atm_equal((struct sockaddr *) entry->addr,(struct sockaddr *) addr,0,
0)))) return result; /* no news */
STOP_TIMER(entry);
if (entry->ip != ip) send_notifications(entry,0);
entry->ip = ip;
if (!entry->itf) {
entry->itf = itf;
/* @@@
* Need to fix this is in case we allow entries without a valid IP
* address but with a pre-set QOS, e.g. a VC on a given PVC with an
* unknown remote end.
*/
entry->qos = entry->itf->qos;
adjust_qos(entry->itf,&entry->qos,0);
Q_INSERT_HEAD(itf->table,entry);
}
if (entry->itf != itf)
diag(COMPONENT,DIAG_ERROR,"interesting, interface has changed ... "
"(%d -> %d)",entry->itf->number,itf->number);
if (addr) {
if (!entry->addr) entry->addr = alloc(sizeof(*addr));
*entry->addr = *addr;
if (merge) {
ENTRY *incoming;
while ((incoming = lookup_incoming(addr))) {
STOP_TIMER(incoming);
Q_REMOVE(unknown_incoming,incoming);
incoming->vccs->entry = entry;
Q_INSERT_HEAD(entry->vccs,incoming->vccs);
set_sndbuf(incoming->vccs);
free(incoming);
}
}
}
for (walk = entry->vccs; walk; walk = next) {
next = walk->next;
if (!walk->connecting)
if (set_ip(walk->fd,ip) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip: %s",strerror(errno));
disconnect_vcc(walk);
if (walk == vcc) result = -1;
}
}
if (entry->state != as_valid) {
if (!entry->vccs && itf->arp_srv && !(entry->flags & ATF_NOVC))
connect_me(entry);
send_notifications(entry,1);
}
if ((entry->flags & ATF_ARPSRV) || !(entry->flags & ATF_PERM)) {
if (entry->itf->arp_srv) START_TIMER(entry,CREVAL);
else START_TIMER(entry,SREVAL);
}
entry->state = as_valid;
return result;
}
static void _eth_spi_handle_frame() {
u16_t rx_stat;
int plen = enc28j60PacketReceive(ETHSPI_MAX_PKT_SIZE, ethspi.rxbuf, &rx_stat);
if (plen == 0) {
DBG(D_ETH, D_DEBUG, "ethspi no frame, rx_stat:%04x\n", rx_stat);
return;
}
#ifdef ETH_STATS
ethspi.rx_frames++;
ethspi.rx_data += plen;
#endif
DBG(D_ETH, D_DEBUG, "ethspi got frame, len %i, rx_stat:%04x\n", plen, rx_stat);
//printbuf(ethspi.rxbuf, MIN(64, plen));
// doing dhcp, do not allow anything else right now
if (ethspi.dhcp.query && ethspi.dhcp.active) {
int dhcp_res;
dhcp_res = check_for_dhcp_answer(ethspi.rxbuf, plen);
DBG(D_ETH, D_DEBUG, "ethspi DHCP:%i state:%i\n", dhcp_res, dhcp_state());
if (dhcp_state() == DHCP_STATE_OK) {
ethspi.dhcp.query = FALSE;
DBG(D_ETH, D_DEBUG, "ethspi DHCP OK\n");
DBG(D_ETH, D_INFO, "ethspi DHCP ip %i.%i.%i.%i\n", ethspi.dhcp.ipaddr[0], ethspi.dhcp.ipaddr[1], ethspi.dhcp.ipaddr[2], ethspi.dhcp.ipaddr[3]);
DBG(D_ETH, D_DEBUG, "ethspi DHCP gwip %i.%i.%i.%i\n", ethspi.dhcp.gwip[0], ethspi.dhcp.gwip[1], ethspi.dhcp.gwip[2], ethspi.dhcp.gwip[3]);
DBG(D_ETH, D_DEBUG, "ethspi DHCP mask %i.%i.%i.%i\n", ethspi.dhcp.mask[0], ethspi.dhcp.mask[1], ethspi.dhcp.mask[2], ethspi.dhcp.mask[3]);
DBG(D_ETH, D_DEBUG, "ethspi DHCP dhcp %i.%i.%i.%i\n", ethspi.dhcp.dhcp_server[0], ethspi.dhcp.dhcp_server[1], ethspi.dhcp.dhcp_server[2], ethspi.dhcp.dhcp_server[3]);
DBG(D_ETH, D_DEBUG, "ethspi DHCP dns %i.%i.%i.%i\n", ethspi.dhcp.dns_server[0], ethspi.dhcp.dns_server[1], ethspi.dhcp.dns_server[2], ethspi.dhcp.dns_server[3]);
memcpy(ip_address, ethspi.dhcp.ipaddr, 4);
set_ip(ethspi.dhcp.ipaddr);
client_set_gwip(ethspi.dhcp.gwip);
#ifdef CONFIG_ETH_DHCP_SHOW
print("eth ip address %i.%i.%i.%i\n", ethspi.dhcp.ipaddr[0], ethspi.dhcp.ipaddr[1], ethspi.dhcp.ipaddr[2], ethspi.dhcp.ipaddr[3]);
#endif
}
return;
}
// arp is broadcast if unknown but a host may also
// verify the mac address by sending it to
// a unicast address.
if (eth_type_is_arp_and_my_ip(ethspi.rxbuf, plen)) {
make_arp_answer_from_request(ethspi.rxbuf);
return;
}
// check if ip frames (icmp or udp) are for us or broadcast:
if (eth_type_is_ip_and_broadcast(ethspi.rxbuf, plen) == 0) {
if (eth_type_is_ip_and_my_ip(ethspi.rxbuf, plen) == 0) {
return;
}
if (ethspi.rxbuf[IP_PROTO_P]==IP_PROTO_ICMP_V &&
ethspi.rxbuf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V){
// a ping frame, let's send pong
make_echo_reply_from_request(ethspi.rxbuf, plen);
return;
}
}
#if 0
// we listen on port 0xcafe
if (ethspi.rxbuf[IP_PROTO_P] == IP_PROTO_UDP_V
&& ethspi.rxbuf[UDP_DST_PORT_H_P] == 0xca && ethspi.rxbuf[UDP_DST_PORT_L_P] == 0xf) {
int payloadlen = ethspi.rxbuf[UDP_LEN_L_P];//plen - 34 - UDP_HEADER_LEN;
DBG(D_ETH, D_DEBUG, "ethspi UDP len:%i\n", payloadlen);
//char *nisse = "hello wurlde";
//make_udp_reply_from_request(ethbuf, nisse, strlen(nisse), 1200);
DBG(D_ETH, D_DEBUG, "ethspi eth mac dst: %02x.%02x.%02x.%02x.%02x.%02x\n",
ethspi.rxbuf[0], ethspi.rxbuf[1], ethspi.rxbuf[2], ethspi.rxbuf[3], ethspi.rxbuf[4], ethspi.rxbuf[5]); // ETH_DST_MAC
DBG(D_ETH, D_DEBUG, "ethspi eth mac src: %02x.%02x.%02x.%02x.%02x.%02x\n",
ethspi.rxbuf[6], ethspi.rxbuf[7], ethspi.rxbuf[8], ethspi.rxbuf[9], ethspi.rxbuf[10], ethspi.rxbuf[11]); // ETH_SRC_MAC
DBG(D_ETH, D_DEBUG, "ethspi eth type: %02x %02x\n",
ethspi.rxbuf[12], ethspi.rxbuf[13]); // ETH_TYPE_H_P, ETH_TYPE_L_P
DBG(D_ETH, D_DEBUG, "ethspi ip src: %i.%i.%i.%i\n",
ethspi.rxbuf[26], ethspi.rxbuf[27], ethspi.rxbuf[28], ethspi.rxbuf[29]); // IP_SRC_P
DBG(D_ETH, D_DEBUG, "ethspi ip dst: %i.%i.%i.%i\n",
ethspi.rxbuf[30], ethspi.rxbuf[31], ethspi.rxbuf[32], ethspi.rxbuf[33]); // IP_DST_P
DBG(D_ETH, D_DEBUG, "ethspi udp src port: %i\n",
(ethspi.rxbuf[34] << 8) | ethspi.rxbuf[35]); // UDP_SRC_PORT_H_P
DBG(D_ETH, D_DEBUG, "ethspi udp dst port: %i\n",
(ethspi.rxbuf[36] << 8) | ethspi.rxbuf[37]); // UDP_DST_PORT_H_P
DBG(D_ETH, D_DEBUG, "ethspi udp len: %04x\n",
(ethspi.rxbuf[38] << 8) | ethspi.rxbuf[39]); // UDP_LEN_H_P
DBG(D_ETH, D_DEBUG, "ethspi udp checksum: %04x\n",
(ethspi.rxbuf[40] << 8) | ethspi.rxbuf[41]); // UDP_CHECKSUM_H_P
}
IF_DBG(D_ETH, D_DEBUG) {
printbuf(ðspi.rxbuf[0], plen);
}
MSNServerMessage::~MSNServerMessage()
{
KEY_MAP values;
QString msg = QString::fromUtf8(m_msg.c_str());
for (;!msg.isEmpty();){
QString line;
int n = msg.find("\r\n");
if (n >= 0){
line = msg.left(n);
msg = msg.mid(n + 2);
}else{
line = msg;
msg = "";
}
n = line.find(":");
if (n < 0)
continue;
values.insert(KEY_MAP::value_type(line.left(n), trim(line.mid(n + 1))));
}
KEY_MAP::iterator it = values.find("ClientIP");
if (it != values.end())
set_ip(&m_client->data.owner.IP, inet_addr((*it).second.latin1()));
it = values.find("Content-Type");
if (it != values.end()){
QString content_type = (*it).second;
content_type = getToken(content_type, ';');
if (content_type == "text/x-msmsgsinitialemailnotification"){
m_client->m_init_mail = "";
it = values.find("Post-URL");
if (it != values.end())
m_client->m_init_mail = (*it).second.latin1();
it = values.find("Inbox-URL");
if (it != values.end())
m_client->m_init_mail += (*it).second.latin1();
it = values.find("Inbox-Unread");
if (it == values.end())
return;
unsigned nUnread = (*it).second.toUInt();
if (nUnread){
clientErrorData data;
data.client = m_client;
data.err_str = "%1";
data.options = NULL;
data.args = strdup(i18n("You have %n unread message", "You have %n unread messages", nUnread).utf8());
data.code = 0;
data.flags = ERR_INFO;
data.id = static_cast<MSNPlugin*>(m_client->protocol()->plugin())->MSNInitMail;
Event e(EventShowError, &data);
e.process();
}
}
if (content_type == "text/x-msmsgsemailnotification"){
m_client->m_new_mail = "";
it = values.find("Post-URL");
if (it != values.end())
m_client->m_new_mail = (*it).second.latin1();
it = values.find("Message-URL");
if (it != values.end())
m_client->m_new_mail += (*it).second.latin1();
QString from;
it = values.find("From-Addr");
if (it != values.end())
from = (*it).second;
QString msg = i18n("You have new mail");
if (!from.isEmpty())
msg = i18n("%1 from %2") .arg(msg) .arg(from);
clientErrorData data;
data.client = m_client;
data.err_str = "%1";
data.options = NULL;
data.args = strdup(msg.utf8());
data.code = 0;
data.flags = ERR_INFO;
data.id = static_cast<MSNPlugin*>(m_client->protocol()->plugin())->MSNNewMail;
Event e(EventShowError, &data);
e.process();
}
}
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_RATExCHANGE:
log(L_DEBUG, "Rate change");
if (m_nSendTimeout < 200){
m_nSendTimeout = m_nSendTimeout + 2;
if (m_sendTimer->isActive()){
m_sendTimer->stop();
m_sendTimer->start(m_nSendTimeout * 500);
}
}
break;
case ICQ_SNACxSRV_RATExINFO:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket();
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket();
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
break;
case ICQ_SNACxSRV_MOTD:
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket();
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if ((unsigned)atol(screen.c_str()) != data.owner.Uin){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
log(L_DEBUG, "Name info");
break;
}
case ICQ_SNACxSRV_SERVICExRESP:{
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_id = tlv(0x0D);
if (tlv_id == NULL){
log(L_WARN, "No service id in response");
break;
}
ServiceSocket *s = NULL;
for (list<ServiceSocket*>::iterator it = m_services.begin(); it != m_services.end(); ++it){
if ((*it)->id() == (unsigned short)(*tlv_id)){
s = *it;
break;
}
}
if (s == NULL){
log(L_WARN, "Service not found");
break;
}
Tlv *tlv_addr = tlv(0x05);
if (tlv_addr == NULL){
s->error_state("No address for service", 0);
break;
}
Tlv *tlv_cookie = tlv(0x06);
if (tlv_cookie == NULL){
s->error_state("No cookie for service", 0);
break;
}
unsigned short port = getPort();
string addr;
addr = (const char*)(*tlv_addr);
char *p = (char*)strchr(addr.c_str(), ':');
if (p){
*p = 0;
port = (unsigned short)atol(p + 1);
}
s->connect(addr.c_str(), port, *tlv_cookie, tlv_cookie->Size());
break;
}
case ICQ_SNACxSRV_READYxSERVER:
log(L_DEBUG, "Server ready");
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_IMxICQ);
if (m_bAIM){
m_socket->writeBuffer
<< 0x00010003L
<< 0x00130003L
<< 0x00020001L
<< 0x00030001L
<< 0x00040001L
<< 0x00060001L
<< 0x00080001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}else{
m_socket->writeBuffer
<< 0x00010004L
<< 0x00130004L
<< 0x00020001L
<< 0x00030001L
<< 0x00150001L
<< 0x00040001L
<< 0x00060001L
<< 0x00090001L
<< 0x000A0001L
<< 0x000B0001L;
}
sendPacket();
break;
case ICQ_SNACxSRV_ERROR:
break;
case ICQ_SNACxSRV_EVIL:{
unsigned short level;
m_socket->readBuffer.unpack(level);
string from = m_socket->readBuffer.unpackScreen();
data.owner.WarningLevel = level;
QString f;
f = from.c_str();
if (f.isEmpty())
f = i18n("anonymous");
clientErrorData d;
d.client = this;
d.code = 0;
d.err_str = I18N_NOOP("You've been warned by %1");
d.args = strdup(f.utf8());
Event e(EventClientError, &d);
e.process();
free(d.args);
break;
}
default:
log(L_WARN, "Unknown service family type %04X", type);
}
void ICQClient::snac_buddy(unsigned short type, unsigned short)
{
string screen;
Contact *contact;
ICQUserData *data;
switch (type){
case ICQ_SNACxBDY_RIGHTSxGRANTED:
log(L_DEBUG, "Buddy rights granted");
break;
case ICQ_SNACxBDY_USEROFFLINE:
screen = m_socket->readBuffer.unpackScreen();
data = findContact(screen.c_str(), NULL, false, contact);
if (data && (data->Status.value != ICQ_STATUS_OFFLINE)){
setOffline(data);
StatusMessage m;
m.setContact(contact->id());
m.setClient(dataName(data).c_str());
m.setStatus(STATUS_OFFLINE);
m.setFlags(MESSAGE_RECEIVED);
Event e(EventMessageReceived, &m);
e.process();
}
break;
case ICQ_SNACxBDY_USERONLINE:
screen = m_socket->readBuffer.unpackScreen();
data = findContact(screen.c_str(), NULL, false, contact);
if (data){
time_t now;
time(&now);
bool bChanged = false;
bool bAwayChanged = false;
unsigned long prevStatus = data->Status.value;
unsigned short level, len;
m_socket->readBuffer >> level >> len;
data->WarningLevel.value = level;
TlvList tlv(m_socket->readBuffer);
Tlv *tlvClass = tlv(0x0001);
if (tlvClass){
unsigned short userClass = *tlvClass;
if (userClass != data->Class.value){
if ((userClass & CLASS_AWAY) != (data->Class.value & CLASS_AWAY)){
data->StatusTime.value = (unsigned long)now;
bAwayChanged = true;
}
data->Class.value = userClass;
bChanged = true;
}
if (data->Uin.value == 0){
if (userClass & CLASS_AWAY){
fetchAwayMessage(data);
}else{
set_str(&data->AutoReply.ptr, NULL);
}
}
}
// Status TLV
Tlv *tlvStatus = tlv(0x0006);
if (tlvStatus){
unsigned long status = *tlvStatus;
if (status != data->Status.value){
data->Status.value = status;
if ((status & 0xFF) == 0)
set_str(&data->AutoReply.ptr, NULL);
data->StatusTime.value = (unsigned long)now;
}
}else if (data->Status.value == ICQ_STATUS_OFFLINE){
data->Status.value = ICQ_STATUS_ONLINE;
data->StatusTime.value = (unsigned long)now;
}
// Online time TLV
Tlv *tlvOnlineTime = tlv(0x0003);
if (tlvOnlineTime){
unsigned long OnlineTime = *tlvOnlineTime;
if (OnlineTime != data->OnlineTime.value){
data->OnlineTime.value = OnlineTime;
bChanged = true;
}
}
Tlv *tlvNATime = tlv(0x0004);
if (tlvNATime){
unsigned short na_time = *tlvNATime;
unsigned long StatusTime = (unsigned long)now - na_time * 60;
if (StatusTime != data->StatusTime.value){
data->StatusTime.value = StatusTime;
bChanged = true;
}
}
// IP TLV
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
bChanged |= set_ip(&data->IP, htonl((unsigned long)(*tlvIP)));
Tlv *tlvCapability = tlv(0x000D);
if (tlvCapability){
data->Caps.value = 0;
Buffer info(*tlvCapability);
for (; info.readPos() < info.size(); ){
capability cap;
info.unpack((char*)cap, sizeof(capability));
for (unsigned i = 0;; i++){
if (*capabilities[i] == 0) break;
unsigned size = sizeof(capability);
if (i == CAP_SIMOLD) size--;
if ((i == CAP_MICQ) || (i == CAP_LICQ) || (i == CAP_SIM)) size -= 4;
if (!memcmp(cap, capabilities[i], size)){
if (i == CAP_SIMOLD){
unsigned char build = cap[sizeof(capability)-1];
if (build && ((build == 0x92) || (build < (1 << 6)))) continue;
data->Build.value = build;
}
if ((i == CAP_MICQ) || (i == CAP_LICQ) || (i == CAP_SIM)){
unsigned char *p = (unsigned char*)cap;
p += 12;
data->Build.value = (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3];
}
data->Caps.value |= (1 << i);
break;
}
}
}
}
unsigned long infoUpdateTime = 0;
unsigned long pluginInfoTime = 0;
unsigned long pluginStatusTime = 0;
// Direct connection info
Tlv *tlvDirect = tlv(0x000C);
if (tlvDirect){
Buffer info(*tlvDirect);
unsigned long realIP;
unsigned short port;
char mode, version, junk;
info >> realIP;
info.incReadPos(2);
info >> port;
if (realIP == 0x7F000001)
realIP = 0;
bChanged |= set_ip(&data->RealIP, htonl(realIP));
data->Port.value = port;
unsigned long DCcookie;
info >> mode >> junk >> version >> DCcookie;
data->DCcookie.value = DCcookie;
info.incReadPos(8);
info
>> infoUpdateTime
>> pluginInfoTime
>> pluginStatusTime;
if (mode == MODE_DENIED) mode = MODE_INDIRECT;
if ((mode != MODE_DIRECT) && (mode != MODE_INDIRECT))
mode = MODE_INDIRECT;
data->Mode.value = mode;
data->Version.value = version;
}
Tlv *tlvPlugin = tlv(0x0011);
if (tlvPlugin && data->Uin.value){
Buffer info(*tlvPlugin);
char type;
unsigned long time;
info >> type;
info.unpack(time);
plugin p;
unsigned plugin_index;
unsigned long plugin_status;
switch (type){
case 1:
addFullInfoRequest(data->Uin.value);
break;
case 2:
info.incReadPos(6);
info.unpack((char*)p, sizeof(p));
data->PluginInfoTime.value = time;
for (plugin_index = 0; plugin_index < PLUGIN_NULL; plugin_index++)
if (!memcmp(p, plugins[plugin_index], sizeof(p)))
break;
switch (plugin_index){
case PLUGIN_PHONEBOOK:
log(L_DEBUG, "Updated phonebook");
addPluginInfoRequest(data->Uin.value, plugin_index);
break;
case PLUGIN_PICTURE:
log(L_DEBUG, "Updated picture");
addPluginInfoRequest(data->Uin.value, plugin_index);
break;
case PLUGIN_QUERYxINFO:
log(L_DEBUG, "Updated info plugin list");
addPluginInfoRequest(data->Uin.value, plugin_index);
break;
default:
if (plugin_index >= PLUGIN_NULL)
log(L_WARN, "Unknown plugin sign");
}
break;
case 3:
info.incReadPos(6);
info.unpack((char*)p, sizeof(p));
info.incReadPos(1);
info.unpack(plugin_status);
data->PluginStatusTime.value = time;
for (plugin_index = 0; plugin_index < PLUGIN_NULL; plugin_index++)
if (!memcmp(p, plugins[plugin_index], sizeof(p)))
break;
switch (plugin_index){
case PLUGIN_FOLLOWME:
if (data->FollowMe.value == plugin_status)
break;
data->FollowMe.value = plugin_status;
bChanged = true;
break;
case PLUGIN_FILESERVER:
if ((data->SharedFiles.value != 0) == (plugin_status != 0))
break;
data->SharedFiles.value = (plugin_status != 0);
bChanged = true;
break;
case PLUGIN_ICQPHONE:
if (data->ICQPhone.value == plugin_status)
break;
data->ICQPhone.value = plugin_status;
bChanged = true;
break;
default:
if (plugin_index >= PLUGIN_NULL)
log(L_WARN, "Unknown plugin sign");
}
break;
}
}else{
data->InfoUpdateTime.value = infoUpdateTime;
data->PluginInfoTime.value = pluginInfoTime;
data->PluginStatusTime.value = pluginStatusTime;
if (getAutoUpdate()){
if (infoUpdateTime == 0)
infoUpdateTime = 1;
if (infoUpdateTime != data->InfoFetchTime.value)
addFullInfoRequest(data->Uin.value);
if ((data->PluginInfoTime.value != data->PluginInfoFetchTime.value)){
if (data->PluginInfoTime.value)
addPluginInfoRequest(data->Uin.value, PLUGIN_QUERYxINFO);
}
if ((data->PluginInfoTime.value != data->PluginInfoFetchTime.value) ||
(data->PluginStatusTime.value != data->PluginStatusFetchTime.value)){
if (data->SharedFiles.bValue){
data->SharedFiles.bValue = false;
bChanged = true;
}
if (data->FollowMe.value){
data->FollowMe.value = 0;
bChanged = true;
}
if (data->ICQPhone.bValue){
data->ICQPhone.bValue = false;
bChanged = true;
}
if (data->PluginStatusTime.value)
addPluginInfoRequest(data->Uin.value, PLUGIN_QUERYxSTATUS);
}
}
}
if (data->bInvisible.bValue){
data->bInvisible.bValue = false;
bChanged = true;
}
if (bChanged){
Event e(EventContactChanged, contact);
e.process();
}
if ((data->Status.value != prevStatus) || bAwayChanged){
unsigned status = STATUS_OFFLINE;
if ((data->Status.value & 0xFFFF) != ICQ_STATUS_OFFLINE){
status = STATUS_ONLINE;
if (data->Status.value & ICQ_STATUS_DND){
status = STATUS_DND;
}else if (data->Status.value & ICQ_STATUS_OCCUPIED){
status = STATUS_OCCUPIED;
}else if (data->Status.value & ICQ_STATUS_NA){
status = STATUS_NA;
}else if (data->Status.value & ICQ_STATUS_AWAY){
status = STATUS_AWAY;
}else if (data->Status.value & ICQ_STATUS_FFC){
status = STATUS_FFC;
}
}
if ((status == STATUS_ONLINE) && (data->Class.value & CLASS_AWAY))
status = STATUS_AWAY;
StatusMessage m;
m.setContact(contact->id());
m.setClient(dataName(data).c_str());
m.setStatus(status);
m.setFlags(MESSAGE_RECEIVED);
Event e(EventMessageReceived, &m);
e.process();
if (!contact->getIgnore() &&
((data->Class.value & CLASS_AWAY) == 0) &&
(((data->Status.value & 0xFF) == ICQ_STATUS_ONLINE) &&
(((prevStatus & 0xFF) != ICQ_STATUS_ONLINE)) || bAwayChanged) &&
(((prevStatus & 0xFFFF) != ICQ_STATUS_OFFLINE) ||
(data->OnlineTime.value > this->data.owner.OnlineTime.value))){
Event e(EventContactOnline, contact);
e.process();
}
if (getAutoReplyUpdate() && ((data->Status.value & 0xFF) != ICQ_STATUS_ONLINE)){
if ((getInvisible() && data->VisibleId.value) ||
(!getInvisible() && (data->InvisibleId.value == 0)))
addPluginInfoRequest(data->Uin.value, PLUGIN_AR);
}
}
}
Worker::Worker(char *parameters[], NoVoHT *novoht) {
/* set thread detachstate attribute to DETACHED */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
/* filename definitions */
set_dir(parameters[9], parameters[10]);
file_worker_start.append(shared);
file_worker_start.append("startinfo");
file_task_fp.append(prefix);
file_task_fp.append("pkgs");
file_migrate_fp.append(prefix);
file_migrate_fp.append("log_migrate");
file_fin_fp.append(prefix);
file_fin_fp.append("finish");
file_log_fp.append(prefix);
file_log_fp.append("log_worker");
pmap = novoht;
Env_var::set_env_var(parameters);
svrclient.initialize(Env_var::cfgFile, Env_var::membershipFile,
Env_var::TCP);
//svrzht.initialize(Env_var::cfgFile, Env_var::membershipFile, Env_var::TCP);
//svrmig.initialize(Env_var::cfgFile, Env_var::membershipFile, Env_var::TCP);
if (set_ip(ip)) {
printf("Could not get the IP address of this machine!\n");
exit(1);
}
for (int i = 0; i < 10; i++) {
msg_count[i] = 0;
}
poll_interval = start_poll;
poll_threshold = start_thresh;
num_nodes = svrclient.memberList.size();
num_cores = atoi(parameters[11]);
ws_sleep = atoi(parameters[12]);
num_idle_cores = num_cores;
neigh_mode = 'd';
//worker.num_neigh = (int)(sqrt(worker.num_nodes));
num_neigh = (int) (sqrt(num_nodes));
neigh_index = new int[num_neigh];
selfIndex = getSelfIndex(ip, atoi(parameters[1]), svrclient.memberList);// replace "localhost" with proper hostname, host is the IP in C++ string
ostringstream oss;
oss << selfIndex;
printf("<ip:selfIndex>: <%s:%d>\n", ip.c_str(), selfIndex);
//string f1 = file_fin_fp;
//f1 = f1 + oss.str();
//fin_fp.open(f1.c_str(), ios_base::app);
if (LOGGING) {
string f2 = file_task_fp;
f2 = f2 + oss.str();
task_fp.open(f2.c_str(), ios_base::app);
string f3 = file_log_fp;
f3 = f3 + oss.str();
log_fp.open(f3.c_str(), ios_base::app);
string f4 = file_migrate_fp;
f4 = f4 + oss.str();
migrate_fp.open(f4.c_str(), ios_base::app);
}
migratev = bitvec(num_nodes);
Package loadPackage, tasksPackage;
string loadmessage("Load Information!");
loadPackage.set_virtualpath(loadmessage);
loadPackage.set_operation(13);
loadstr = loadPackage.SerializeAsString();
stringstream selfIndexstream;
selfIndexstream << selfIndex;
string taskmessage(selfIndexstream.str());
tasksPackage.set_virtualpath(taskmessage);
tasksPackage.set_operation(14);
taskstr = tasksPackage.SerializeAsString();
srand((selfIndex + 1) * (selfIndex + 5));
int rand_wait = rand() % 1000000;
cout << "Worker ip = " << ip << " selfIndex = " << selfIndex << endl;
//cout << "Worker ip = " << ip << " selfIndex = " << selfIndex << " going to wait for " << rand_wait << " seconds" << endl;
usleep(rand_wait);
file_worker_start.append(oss.str());
string cmd("touch ");
cmd.append(file_worker_start);
//executeShell(cmd);
system(cmd.c_str());
FILE *fp = fopen(file_worker_start.c_str(), "w+");
if (fp != NULL) {
//fputs("fopen example", fp);
char fbuf[100];
memset(fbuf, 0, sizeof(fbuf));
sprintf(fbuf, "%s:%d ", ip.c_str(), selfIndex);
fwrite(fbuf, sizeof(char), strlen(fbuf), fp);
fflush(fp);
fclose(fp);
}
/*worker_start.open(file_worker_start.c_str(),
std::ofstream::out | ios_base::app);
if (worker_start.is_open()) {
worker_start << ip << ":" << selfIndex << " ";
worker_start.flush();
worker_start.close();
worker_start.open(file_worker_start.c_str(), ios_base::app);
}
worker_start.open(file_worker_start.c_str(),
std::ofstream::out | ios_base::app);
*/
clock_gettime(CLOCK_REALTIME, &poll_start);
int err;
/*pthread_t *ready_queue_thread = new pthread_t();//(pthread_t*)malloc(sizeof(pthread_t));
pthread_create(ready_queue_thread, &attr, check_ready_queue, NULL);*/
try {
pthread_t *ready_queue_thread = new pthread_t[num_cores];
for (int i = 0; i < num_cores; i++) {
err = pthread_create(&ready_queue_thread[i], &attr,
check_ready_queue, (void*) this);
if (err) {
printf(
"work_steal_init: pthread_create: ready_queue_thread: %s\n",
strerror(errno));
exit(1);
}
}
pthread_t *wait_queue_thread = new pthread_t();
err = pthread_create(wait_queue_thread, &attr, check_wait_queue,
(void*) this);
if (err) {
printf("work_steal_init: pthread_create: wait_queue_thread: %s\n",
strerror(errno));
exit(1);
}
pthread_t *complete_queue_thread = new pthread_t();
err = pthread_create(complete_queue_thread, &attr, check_complete_queue,
(void*) this);
if (err) {
printf(
"work_steal_init: pthread_create: complete_queue_thread: %s\n",
strerror(errno));
exit(1);
}
package_thread_args rq_args, wq_args;
rq_args.source = &insertq_new;
wq_args.source = &waitq;
rq_args.dest = &rqueue;
wq_args.dest = &wqueue;
rq_args.slock = &iq_new_lock;
wq_args.slock = &waitq_lock;
rq_args.dlock = &lock;
wq_args.dlock = &w_lock;
rq_args.worker = this;
wq_args.worker = this;
pthread_t *waitq_thread = new pthread_t();
err = pthread_create(waitq_thread, &attr, HB_insertQ_new,
(void*) &wq_args);
if (err) {
printf("work_steal_init: pthread_create: waitq_thread: %s\n",
strerror(errno));
exit(1);
}
pthread_t *readyq_thread = new pthread_t();
err = pthread_create(readyq_thread, &attr, HB_insertQ_new,
(void*) &rq_args);
if (err) {
printf("work_steal_init: pthread_create: ready_thread: %s\n",
strerror(errno));
exit(1);
}
pthread_t *migrateq_thread = new pthread_t();
err = pthread_create(migrateq_thread, &attr, migrateTasks,
(void*) this);
if (err) {
printf("work_steal_init: pthread_create: migrateq_thread: %s\n",
strerror(errno));
exit(1);
}
pthread_t *notq_thread = new pthread_t();
err = pthread_create(notq_thread, &attr, notQueue, (void*) this);
if (err) {
printf("work_steal_init: pthread_create: notq_thread: %s\n",
strerror(errno));
exit(1);
}
int min_lines = svrclient.memberList.size();
//min_lines++;
string filename(file_worker_start);
//string cmd("wc -l ");
//cmd = cmd + filename + " | awk {\'print $1\'}";
string cmd2("ls -l ");
cmd2.append(shared);
cmd2.append("startinfo*");
cmd2.append(" | wc -l");
string result = executeShell(cmd2);
//cout << "server: minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl;
while (atoi(result.c_str()) < min_lines) {
sleep(2);
//cout << "server: " << worker.selfIndex << " minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl;
result = executeShell(cmd2);
}
//cout << "server: " << selfIndex << " minlines = " << min_lines << " cmd = " << cmd2 << " result = " << result << endl;
/*int num = min_lines - 1;
stringstream num_ss;
num_ss << num;
//min_lines++;
string cmd1("cat "); cmd1.append(shared); cmd1.append("startinfo"); cmd1.append(num_ss.str()); cmd1.append(" | wc -l");
string result1 = executeShell(cmd1);
//cout << "server: minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl;
while(atoi(result1.c_str()) < 1) {
sleep(2);
result1 = executeShell(cmd1);
}
cout << "worksteal started: server: " << selfIndex << " minlines = " << 1 << " cmd = " << cmd1 << " result = " << result1 << endl;*/
pthread_t *work_steal_thread = new pthread_t(); //(pthread_t*)malloc(sizeof(pthread_t));
err = pthread_create(work_steal_thread, &attr, worksteal, (void*) this);
if (err) {
printf("work_steal_init: pthread_create: work_steal_thread: %s\n",
strerror(errno));
exit(1);
}
delete ready_queue_thread;
delete wait_queue_thread;
delete complete_queue_thread;
delete work_steal_thread;
delete readyq_thread;
delete waitq_thread;
delete migrateq_thread;
delete notq_thread;
} catch (std::bad_alloc& exc) {
cout
<< "work_steal_init: failed to allocate memory while creating threads"
<< endl;
exit(1);
}
}
void ICQClient::snac_service(unsigned short type, unsigned short)
{
switch (type){
case ICQ_SNACxSRV_PAUSE:
log(L_DEBUG, "Server pause");
m_bNoSend = true;
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_PAUSExACK);
m_socket->writeBuffer << ICQ_SNACxFAM_SERVICE
<< ICQ_SNACxFAM_LOCATION
<< ICQ_SNACxFAM_BUDDY
<< ICQ_SNACxFAM_MESSAGE
<< ICQ_SNACxFAM_BOS
<< ICQ_SNACxFAM_PING
<< ICQ_SNACxFAM_LISTS
<< ICQ_SNACxFAM_VARIOUS
<< ICQ_SNACxFAM_LOGIN;
sendPacket(true);
break;
case ICQ_SNACxSRV_RESUME:
log(L_DEBUG, "Server resume");
m_bNoSend = false;
processSendQueue();
break;
case ICQ_SNACxSRV_MIGRATE:{
log(L_DEBUG, "Server migrate");
m_bNoSend = true;
int i;
unsigned short cnt;
unsigned short fam[0x17];
m_socket->readBuffer >> cnt;
for (i = 0; i < cnt; i++) {
m_socket->readBuffer >> fam[i];
}
TlvList tlv(m_socket->readBuffer);
Tlv *tlv_adr = tlv(0x05);
Tlv *tlv_cookie = tlv(0x06);
for (; i >= 0; i--) {
setServiceSocket(tlv_adr,tlv_cookie,fam[i]);
}
break;
}
case ICQ_SNACxSRV_RATExCHANGE:{
const char *msg_text = NULL;
unsigned short msg_code;
unsigned short class_id;
unsigned long window_size;
unsigned long clear_level;
unsigned long alert_level;
unsigned long limit_level;
unsigned long discon_level;
unsigned long current_level;
unsigned long max_level;
unsigned long last_send;
char current_state;
m_socket->readBuffer >> msg_code
>> class_id
>> window_size
>> clear_level
>> alert_level
>> limit_level
>> discon_level
>> current_level
>> max_level
>> last_send
>> current_state;
if (type == ICQ_SNACxSRV_RATExCHANGE){
switch (msg_code) {
case 0x0001:
msg_text = "Rate limits parameters changed";
break;
case 0x0002:
msg_text = "Rate limits warning";
break;
case 0x0003:
msg_text = "Rate limit hit";
break;
case 0x0004:
msg_text = "Rate limit clear";
break;
default:
msg_text = "Unknown";
}
log(L_DEBUG, "%s", msg_text);
}
log(L_DEBUG, "grp: %02X, ws: %04lX, cl %04lX, al %04lX, ll %04lX, dl: %04lX, cur %04lX, ml %04lX",
class_id,window_size,clear_level,alert_level,limit_level,discon_level,
current_level,max_level);
if (--class_id < m_rates.size()){
RateInfo &r = m_rates[class_id];
r.m_winSize = window_size;
r.m_maxLevel = max_level;
r.m_minLevel = alert_level;
r.m_curLevel = current_level;
r.m_lastSend = QDateTime::currentDateTime();
processSendQueue();
}
break;
}
case ICQ_SNACxSRV_RATExINFO:
if (m_rates.size() == 0){
unsigned short n_rates;
m_socket->readBuffer >> n_rates;
unsigned n;
for (n = 0; n < n_rates; n++){
unsigned short class_id;
unsigned long window_size;
unsigned long clear_level;
unsigned long alert_level;
unsigned long limit_level;
unsigned long discon_level;
unsigned long current_level;
unsigned long max_level;
unsigned long last_send;
char current_state;
m_socket->readBuffer
>> class_id
>> window_size
>> clear_level
>> alert_level
>> limit_level
>> discon_level
>> current_level
>> max_level
>> last_send
>> current_state;
log(L_DEBUG, "grp: %02X, ws: %04lX, cl %04lX, al %04lX, ll %04lX, dl: %04lX, cur %04lX, ml %04lX",
class_id,window_size,clear_level,alert_level,limit_level,discon_level,
current_level,max_level);
RateInfo r;
r.m_winSize = window_size;
r.m_minLevel = alert_level;
r.m_maxLevel = max_level;
r.m_curLevel = current_level;
r.m_lastSend = QDateTime::currentDateTime();
m_rates.push_back(r);
}
for (n = 0; n < n_rates; n++){
unsigned short class_id;
unsigned short pairs;
m_socket->readBuffer
>> class_id
>> pairs;
class_id--;
for (unsigned i = 0; i < pairs; i++){
unsigned long snac;
m_socket->readBuffer >> snac;
if (class_id >= m_rates.size())
continue;
RATE_MAP::iterator it = m_rate_grp.find(snac);
if (it != m_rate_grp.end())
continue;
m_rate_grp.insert(RATE_MAP::value_type(snac, class_id));
}
}
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_RATExACK);
m_socket->writeBuffer << 0x00010002L << 0x00030004L << 0x0005;
sendPacket(true);
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_GETxUSERxINFO);
sendPacket(true);
listsRequest();
locationRequest();
buddyRequest();
icmbRequest();
bosRequest();
}
break;
case ICQ_SNACxSRV_MOTD:
break;
case ICQ_SNACxSRV_ACKxIMxICQ:
snac(ICQ_SNACxFAM_SERVICE, ICQ_SNACxSRV_REQxRATExINFO);
sendPacket(true);
break;
case ICQ_SNACxSRV_NAMExINFO:{
string screen = m_socket->readBuffer.unpackScreen();
if (screen.length() == 0){
char n;
m_socket->readBuffer >> n;
m_socket->readBuffer.incReadPos(n);
screen = m_socket->readBuffer.unpackScreen();
}
if ((unsigned)atol(screen.c_str()) != data.owner.Uin.value){
log(L_WARN, "No my name info (%s)", screen.c_str());
break;
}
m_socket->readBuffer.incReadPos(4);
TlvList tlv(m_socket->readBuffer);
Tlv *tlvIP = tlv(0x000A);
if (tlvIP)
set_ip(&data.owner.IP, htonl((unsigned long)(*tlvIP)));
break;
}
int addr_to_int (char *all_ip, int *ip1, int *ip2, int *ip3, int *ip4)
{
memset (temp, ' ', strlen(temp));
memset (addr_in, '\0', sizeof(char) * 16);
memcpy(addr_in, all_ip, strlen(all_ip));
l_ip1 = ip1;
l_ip2 = ip2;
l_ip3 = ip3;
l_ip4 = ip4;
i = 0;
j = 0;
next = 1;
while (addr_in[i] != '\0')
{
if (addr_in[i] == '.')
{
i++;
j = 0;
set_ip();
next++;
}
if ((addr_in[i] >= '0')||(addr_in[i] <= '9'))
{
switch (next)
{
case 1:
temp[j] = addr_in[i];
j++;
break;
case 2:
temp[j] = addr_in[i];
j++;
break;
case 3:
temp[j] = addr_in[i];
j++;
break;
case 4:
temp[j] = addr_in[i];
j++;
break;
}
}
else
{
printf ("ERROR 0-9\n");
}
i++;
}
set_ip();
if ((*ip1 > 0)&&(*ip2 >= 0)&&(*ip3 >= 0)&&(*ip4 > 0)) //for ipaddress
return 1;
if ((*ip1 > 0)&&(*ip2 == 0)&&(*ip3 == 0)&&(*ip4 == 0)) //for port
return 0;
else //for error
return -1;
}
