bool IoTCP::save(Image & image, JSON & data)
{
int sock;
struct sockaddr_in echoServAddr;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) >= 0)
{
memset(&echoServAddr, 0, sizeof(echoServAddr));
echoServAddr.sin_family = AF_INET;
echoServAddr.sin_addr.s_addr = inet_addr(getIp());
echoServAddr.sin_port = htons(getPort());
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 100000;
setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
if (connect(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) >= 0)
{
BINFO << "IoTCP: sending TCP packet to " + (std::string) getIp() + ":" + helper::to_string(getPort());
if (send(sock, getMessage(), strlen(getMessage()), 0) != strlen(getMessage()))
{
throw new SocketException("send() sent a different number of bytes than expected");
}
close(sock);
}
}
return true;
}
void getIp(string &s, int st, int n, string now, vector<string> &res)
{
if (st==s.length() && n==4)
{
res.push_back(now.substr(1, now.length()-1));
return;
}
if (st+1<=s.length())
{
int temp = atoi(s.substr(st, 1).c_str());
if (temp>=0 && temp<=255)
getIp(s, st+1, n+1, now+'.'+s.substr(st,1), res);
}
if (st+2<=s.length() && s[st]!='0')
{
int temp = atoi(s.substr(st, 2).c_str());
if (temp>=0 && temp<=255)
getIp(s, st+2, n+1, now+'.'+s.substr(st,2), res);
}
if (st+3<=s.length() && s[st]!='0')
{
int temp = atoi(s.substr(st, 3).c_str());
if (temp>=0 && temp<=255)
getIp(s, st+3, n+1, now+'.'+s.substr(st,3), res);
}
}
std::string Avatar::getAdditionString() const
{
if (!getIp().empty())
return " - " + getIp();
else
return "";
}
postoperation::postoperation(QWidget *parent) :
QDialog(parent),
ui(new Ui::postoperation)
{
ui->setupUi(this);
//
ui->pbPost->setFocusPolicy(Qt::NoFocus);//设置按钮无焦点
ui->pbSearch->setFocusPolicy(Qt::NoFocus);//设置按钮无焦点
ui->pbReturn->setFocusPolicy(Qt::NoFocus);//设置按钮无焦点
ui->pbsendfile->setFocusPolicy(Qt::NoFocus);//设置按钮无焦点
//IP
localIpStr = getIp();
ui->label_ipaddress->setText(localIpStr);
//
loadSize = 4*1024;
totalBytes = 0;
bytesWritten = 0;
bytesToWrite = 0;
tcpClient = new QTcpSocket(this);
connect(tcpClient,SIGNAL(connected()),this,SLOT(startTransfer()));
//当连接服务器成功时，发出connected()信号，我们开始传送文件
connect(tcpClient,SIGNAL(bytesWritten(qint64)),this,SLOT(updateClientProgress(qint64)));
//当有数据发送成功时，我们更新进度条
connect(tcpClient,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(displayError(QAbstractSocket::SocketError)));
}
void CGprsSynthesize::ActivatePDPcontextAccept(SPcapSignal& signal)
{
CKey key(signal.currai, signal.curtlli);
CUserInfo* pUserInfo = m_InfoDB.FindUserInfo(key);
if(!pUserInfo)
{
printf("GPRS activate pdp accept, can't find UserInfo: ri[%lld] tlli[%d]\n", signal.currai.value, signal.curtlli);
return;
}
//pUserInfo->TDR.SetEndTime();
pUserInfo->TDR.SetEndTime(getTime(signal.pdu));
pUserInfo->TDR.SetType(GPRS_PDP_ATCTIVE_EVENT);
pUserInfo->TDR.SetResult(true);
pUserInfo->TDR.SetCause(getSmCause(signal.pdu));
//pUserInfo->TDR.Output();
sysPtr->writeGPRSTDR(&pUserInfo->TDR.m_Tdr);
//pUserInfo->CDR.SetResponseTime();
pUserInfo->CDR.SetResponseTime(getTime(signal.pdu));
pUserInfo->CDR.SetIp(getIp(signal.pdu));
pUserInfo->CDR.SetResult(true);
pUserInfo->CDR.SetCause(getSmCause(signal.pdu));
pUserInfo->CDR.SetNegotiatedQos(getNegotiatedQos(signal.pdu));
//pUserInfo->SESSION.Open(pUserInfo->CDR.SetFileName());
char fn[128] = {0};
pUserInfo->CDR.SetFileName();
sprintf(fn, "%s/%s", sysPtr->getSysCfg().szGbLocalDir, pUserInfo->CDR.m_Cdr.m_FileName);
pUserInfo->SESSION.Open(fn);
return;
}
t_queue* enviarRecursoOrquestador(recursosPersonajesStruct *unPersonaje)
{
t_log *log = log_create(logName,"Nivel",FALSE,LOG_LEVEL_INFO);
int32_t length,size;
liberadosNoSerializadoStruct colaLib;
colaNoSerializadaStruct *colaAsig;
nivelYPersonaje nivelYPersonaje;
colaLib.cola=unPersonaje->recursos;
void *data = serializador_liberados(&colaLib,&size);
length = size + sizeof(header_t);
int32_t socketOrquestador = socketCreateClient(getIp(nivel.orquestador), getPort(nivel.orquestador));
nivelYPersonaje.personaje = unPersonaje->simbolo;
strcpy(nivelYPersonaje.nivelNombre,nivel.nombre);
socketSend(socketOrquestador, data, length);
socketSend(socketOrquestador, &(nivelYPersonaje), sizeof(char[30]));
recv(socketOrquestador,&length,sizeof(int32_t),MSG_WAITALL);
void *buffer = malloc(length);
recv(socketOrquestador,buffer,length,MSG_WAITALL);
colaAsig = desserializador_recursos(buffer);
shutdown(socketOrquestador,2);
log_destroy(log);
return colaAsig->cola;
}
void CDataSocket::recalculateRemoteHost()
{
if (m_socket)
{
IPaddress* addr = SDLNet_TCP_GetPeerAddress(m_socket);
m_remoteHost = getIp(addr->host);
}
}
DWORD CodeChunk::getInstructionAddress(DWORD va) const {
DWORD newVa = getNewVa(va);
if (newVa == -1) {
return (DWORD)-1;
}
return newVa+getIp();
}
vector<string> restoreIpAddresses(string s) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
vector<string> res;
if (s.length()<4 || s.length()>12) return res;
getIp(s, 0, 0, "", res);
return res;
}
bool Identity::isTcpActive(const Client* c) const {
if(c != NULL && user == ClientManager::getInstance()->getMe()) {
return c->isActive(); // userlist should display our real mode
} else {
return (!user->isSet(User::NMDC)) ?
!getIp().empty() && supports(AdcHub::TCP4_FEATURE) :
!user->isSet(User::PASSIVE);
}
}
TEST(Address_cout, WhenCoutShouldPrintRight){
auto address = vss::DomainRandomizer::createRandomAddress();
testing::internal::CaptureStdout();
std::cout << address;
std::string output = testing::internal::GetCapturedStdout();
std::stringstream mock_output;
mock_output << address.getIp() << ":" << address.getPort();
EXPECT_STREQ(mock_output.str().c_str(), output.c_str());
}
std::string HttpsEndpoint::asString() const
{
MemOstream os;
std::string ip = getIp();
if (ip.empty())
{
ip = "127.0.0.1";
}
os << "HTTPS endpoint " << ip << ":" << getPort();
return os.string();
}
std::string TcpEndpoint::asString() const
{
std::ostringstream os;
std::string ip = getIp();
if (ip.empty())
{
ip = "127.0.0.1";
}
os << "TCP endpoint " << ip << ":" << getPort();
return os.str();
}
std::string DocumentBrowser::Drive::getHost() const
{
const uint32_t ip_address = getIp();
char host[16];
if(ip_address)
{
snprintf(host, sizeof host, "%u.%u.%u.%u",
(ip_address & 0xff000000) >> 24,
(ip_address & 0x00ff0000) >> 16,
(ip_address & 0x0000ff00) >> 8,
(ip_address & 0x000000ff));
}
return host;
}
int main(void)
{
char pp[14]={"\0"};
char bufy[33]={"\0"};
char macadd[18]={"\0"};
char ipStr[16]={"\0"};
getmac(macadd);
get_timestamp(pp);
getIp(ipStr);
getMd5((unsigned char *)pp,bufy);
printf("TIME:%s\n",pp);
printf("MD5:%s\n",bufy);
printf("IP:%s\n",ipStr);
printf("MAC:%s\n",macadd);
getchar();
}
int main(int argc, char *argv[]) {
struct sockaddr_ll device;
char NetInterface[10];
strcpy(NetInterface, argv[1]);
int index = if_nametoindex ((const char*)NetInterface);
printf("index is %d\n", index);
//get MAC， 要设置初始值
char MAC[18]={0};
char end[] = "0";
getMac(MAC, argv[1]);
printf("%s\n", MAC);
unsigned char ip[4];
getIp(ip, argv[1]);
printf("\n");
return 0;
}
void Client::parseClientAuth()
{
qDebug() << "parseClientAuth():";
if (this->status_ != ST_CONNECTED)
{
qDebug() << "cmd not allowed";
this->disconnectFromHost();
return;
}
qDebug() << buf_.size();
if (buf_.size() < CMD1_AUTH_SIZE)
return; // not all data avaliable
this->status_ = ST_CLIENT;
ClientInfo* clientInfo = new ClientInfo;
clientInfo->hash = getClientHash(buf_);
clientInfo->os = getClientOs(buf_);
clientInfo->deviceType = getClientDevice(buf_);
ClientInfoStorage::ClientInfo storeInfo;
storeInfo.hash = clientInfo->hash;
storeInfo.ip = QHostAddress(getIp()); // TODO: some refactor here!!
storeInfo.os = clientInfo->os; // storeInfo for saving client;
storeInfo.device = clientInfo->deviceType; // clientInfo - for client? mb not needed?
storage_->updateClient(storeInfo); // to storage
clientInfo->caption=storage_->getCaption(clientInfo->hash);
this->clientInfo_.reset(clientInfo); // to self
qDebug() << "new client authorized";
this->getServer()->resendListToAdmins();
buf_ = buf_.right(buf_.size() - CMD1_AUTH_SIZE);
if (buf_.size() > 0)
onDataReceived(); // If something in buffer - parse again
}
void algoritmoInterbloqueo(int32_t numeroPersonajes)
{
t_log *log = log_create(logName,"Nivel",FALSE,LOG_LEVEL_INFO);
t_log *log2 = log_create("matriz.log","matriz",FALSE,LOG_LEVEL_INFO);
t_list *peticionesActuales, *asignados,*disponibles,*simbolosPersonajes;
t_list *peticionesPorProceso,*procesoAsignados;
simboloStruct *unSimbolo;
void* buffer;
int32_t nProcesos;
int32_t socketOrquestador;
int32_t nRecursos = list_size(nivel.cajas);
int32_t i;
colaNoSerializadaStruct colaInterbloqueo;
int32_t length;
int16_t size=0;
unRecursoPaquetizadoStruct *instanciasDisponibles,*instanciasPedidas,*instanciasAsignadas;
int32_t aux= TRUE, proc,r;
t_queue *enInterbloqueo;
if (!listaPersonajes)
listaPersonajes = list_create();
nProcesos = numeroPersonajes;
if (nProcesos > 0)
{
disponibles=obtenerMatrizDisponibles();
asignados=obtenerMatrizAsignados(listaPersonajes,numeroPersonajes);
peticionesActuales=obtenerPeticionesActuales(listaPersonajes,numeroPersonajes);
simbolosPersonajes=obtenerListaSimbolos(listaPersonajes,numeroPersonajes);
mostrarMatrizPeticiones(peticionesActuales,simbolosPersonajes);
mostrarMatrizASIG(asignados,simbolosPersonajes);
disponiblesMatriz(disponibles);
//elimino los que no tienen asignados
for (proc = 0; proc < nProcesos; proc++)
{
procesoAsignados = (t_list *) list_get(asignados,proc);
bool condicionCeros(void* recurso) {
return (((unRecursoPaquetizadoStruct *) recurso)->recurso != 0);
}
if ( list_size(list_filter(procesoAsignados,condicionCeros)) == 0 )
{
list_remove_and_destroy_element(peticionesActuales,proc,element_destroyer);
list_remove_and_destroy_element(asignados,proc,element_destroyer);
unSimbolo = list_remove(simbolosPersonajes,proc);
free(unSimbolo);
nProcesos--;
proc--;
}
}
aux = TRUE;
proc = 0;
if (nProcesos > 0)
{
for (proc = 0; proc < nProcesos; proc++ )
{
log_info(log2,"Chequeando proceso %c",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo);
aux = TRUE;
//lista de un solo proceso (como si fuera un arreglo)
peticionesPorProceso = (t_list *) list_get(peticionesActuales,proc);
procesoAsignados = (t_list *) list_get(asignados,proc);
for (r=0; r < nRecursos; r++)
{
instanciasDisponibles = (unRecursoPaquetizadoStruct *) list_get(disponibles,r);
instanciasPedidas = (unRecursoPaquetizadoStruct *) list_get(peticionesPorProceso,r);
instanciasAsignadas = (unRecursoPaquetizadoStruct *) list_get(procesoAsignados,r);
// comprobamos que haya recursos suficientes
aux = (instanciasPedidas->recurso - instanciasDisponibles->recurso) <= 0;
if (!aux)
{
log_info(log2,"%c todavia necesita %d instancias de %c",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo,instanciasPedidas->recurso,((cajaStruct *)list_get(nivel.cajas,r))->simbolo);
log_info(log2,"hay %d instancias",instanciasDisponibles->recurso);
break;
}
}
if (aux)
{
log_info(log2,"suponemos que %c termina",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo);
aniadirYeliminar(disponibles, asignados, proc);
//remover indice de maximos
list_remove_and_destroy_element(peticionesActuales,proc,element_destroyer);
unSimbolo = list_remove(simbolosPersonajes,proc);
free(unSimbolo);
nProcesos--;
proc = -1;
if (nProcesos == 0)
{
log_info(log,"Es estado seguro");
log_info(log2,"Es estado seguro");
log_destroy(log);
log_destroy(log2);
list_destroy(disponibles);
list_destroy(asignados);
list_destroy(peticionesActuales);
list_destroy(simbolosPersonajes);
return;
}
}
}
log_info(log,"Es Interbloqueo");
log_info(log2,"Es Interbloqueo");
for (i=0 ; i < list_size(simbolosPersonajes) ; i++)
log_info(log,"Personaje en interbloqueo: %c",((simboloStruct *) list_get(simbolosPersonajes,i))->simbolo);
if (nivel.recovery == 1)
{
enInterbloqueo=queue_create();
socketOrquestador = socketCreateClient(getIp(nivel.orquestador), getPort(nivel.orquestador));
for (i=0 ; i < list_size(simbolosPersonajes) ; i++)
{
queue_push(enInterbloqueo,list_get(simbolosPersonajes,i));
}
colaInterbloqueo.cantidadPersonajes=list_size(simbolosPersonajes);
colaInterbloqueo.cola = enInterbloqueo;
buffer = serializador_interbloqueo(&colaInterbloqueo,&size);
length = size + sizeof(header_t);
socketSend(socketOrquestador,buffer,length);
socketSend(socketOrquestador, &(nivel.nombre), sizeof(char[30]));
shutdown(socketOrquestador,2);
queue_destroy(enInterbloqueo);
free(buffer);
}
}
list_destroy(disponibles);
list_destroy(asignados);
list_destroy(peticionesActuales);
list_destroy(simbolosPersonajes);
}
// renyang-TODO - 加入Vedio的部分吧
// renyang - 分析這一個封包是什麼種類的封包
bool Receiver::processPacket(Packet *p)
{
#ifdef REN_DEBUG
qWarning("Receiver::processPacket(Packet *p)");
#endif
switch (p->getInfo())
{
case IHU_INFO_CRYPTED_AUDIO:
if (blowfish)
{
// renyang - 解碼
p->decrypt(blowfish);
}
else
{
if (!nodecrypt)
{
emitSignal(SIGNAL_KEYREQUEST);
}
break;
}
case IHU_INFO_AUDIO:
// renyang - 取出資料, 並且通知有新資料到
if (p->getDataLen() > MIN_DATA_SIZE)
{
emit newAudioData(p->getData(), p->getDataLen());
}
connected = true;
break;
case IHU_INFO_NEW_KEY:
if (p->getDataLen() > MIN_DATA_SIZE)
{
char *out;
int len = rsa->decrypt(p->getData(), p->getDataLen(), &out);
if (blowfish)
delete blowfish;
blowfish = new Blowfish(out, len);
emitSignal(SIGNAL_NEWKEY);
free(out);
}
break;
case IHU_INFO_KEY_REQUEST:
if (p->getDataLen() > MIN_DATA_SIZE)
{
rsa->setPeerPublicKey(p->getData(), p->getDataLen());
emitSignal(SIGNAL_SENDNEWKEY);
}
break;
case IHU_INFO_RING:
if (p->getDataLen() > MIN_DATA_SIZE)
{
ihu_reply = true;
QString tempName = p->getData();
if (!tempName.isEmpty())
callerName = tempName;
}
emit warning(QString("!! CALL from %1 (%2) !!").arg(getIp()).arg(getCallerName()));
emitSignal(SIGNAL_RING);
break;
case IHU_INFO_ANSWER:
connected = true;
case IHU_INFO_RING_REPLY:
ihu_reply = true;
if (p->getDataLen() > MIN_DATA_SIZE)
callerName = p->getData();
break;
case IHU_INFO_ERROR:
ihu_abort = true;
case IHU_INFO_REFUSE:
ihu_refuse = true;
case IHU_INFO_CLOSE:
emitSignal(SIGNAL_FINISH);
break;
case IHU_INFO_INIT:
emitSignal(SIGNAL_INIT);
case IHU_INFO_RESET:
disableDecrypt();
break;
}
return true;
}
// renyang-TODO - 加入Vedio的部分吧
// renyang - 分析這一個封包是什麼種類的封包
// renyang - 依不同的封包, 做不一樣的事情
bool Receiver::processPacket(Packet *p)
{
#ifdef REN_DEBUG
qWarning("Receiver::processPacket(Packet *p)");
#endif
switch (p->getInfo())
{
case IHU_INFO_CRYPTED_AUDIO:
if (blowfish)
{
// renyang - 解碼
p->decrypt(blowfish);
}
else
{
if (!nodecrypt)
{
emitSignal(SIGNAL_KEYREQUEST);
}
break;
}
case IHU_INFO_AUDIO:
// renyang - 取出資料, 並且通知有新資料到
if (p->getDataLen() > MIN_DATA_SIZE)
{
emit newAudioData(p->getData(), p->getDataLen());
}
connected = true;
break;
case IHU_INFO_NEW_KEY:
if (p->getDataLen() > MIN_DATA_SIZE)
{
char *out;
int len = rsa->decrypt(p->getData(), p->getDataLen(), &out);
if (blowfish)
delete blowfish;
blowfish = new Blowfish(out, len);
emitSignal(SIGNAL_NEWKEY);
free(out);
}
break;
case IHU_INFO_KEY_REQUEST:
if (p->getDataLen() > MIN_DATA_SIZE)
{
rsa->setPeerPublicKey(p->getData(), p->getDataLen());
emitSignal(SIGNAL_SENDNEWKEY);
}
break;
case IHU_INFO_RING:
if (p->getDataLen() > MIN_DATA_SIZE)
{
ihu_reply = true;
QString tempName = p->getData();
if (!tempName.isEmpty())
callerName = tempName;
}
emit warning(QString("!! CALL from %1 (%2) !!").arg(getIp()).arg(getCallerName()));
emitSignal(SIGNAL_RING);
break;
case IHU_INFO_ANSWER:
// renyang - 對方答應接應電話啦
connected = true;
case IHU_INFO_RING_REPLY:
// renyang - 對方還沒有要接通電話
ihu_reply = true;
if (p->getDataLen() > MIN_DATA_SIZE)
callerName = p->getData();
break;
case IHU_INFO_ERROR:
ihu_abort = true;
case IHU_INFO_REFUSE:
// renyang - 對方拒絕接通電話
ihu_refuse = true;
case IHU_INFO_CLOSE:
emitSignal(SIGNAL_FINISH);
break;
case IHU_INFO_INIT:
emitSignal(SIGNAL_INIT);
case IHU_INFO_RESET:
disableDecrypt();
break;
// renyang - 對方要求Image(影像)
case IHU_INFO_VIDEO_REQUEST:
emit requestImage();
break;
// renyang-modify - 要求對方影像失敗
case IHU_INFO_VIDEO_ERROR:
emit requestImageFail();
break;
case IHU_INFO_VIDEO:
// renyang-modify - 接收到片斷的image, 把資料放到Call::RecvImage中
if (p->getDataLen() > MIN_DATA_SIZE)
{
emit newVideoData(p->getData(), p->getDataLen());
}
connected = true;
break;
case IHU_INFO_VIDEO_NEXT:
emit requestNextImage();
break;
case IHU_INFO_VIDEO_END:
emit completeImage();
break;
case IHU_INFO_VIDEO_CONFIRM:
// renyang-modify - 只是用來確認線路是否是通的
break;
}
return true;
}
std::string str()
{
return std::string(getIp() + DELIMITER + getPort());
}
bool Identity::isUdpActive() const {
if(getIp().empty() || getUdpPort().empty())
return false;
return (!user->isSet(User::NMDC)) ? supports(AdcHub::UDP4_FEATURE) : !user->isSet(User::PASSIVE);
}
