netaddr::netaddr(std::string host, int type) {
std::unique_ptr<struct addrinfo, freeaddrinfo_proto> saddr(nullptr, &freeaddrinfo);
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = type;
hints.ai_socktype = 0;
int stat = 0;
std::cout << "Getting address for host " << host << std::endl;
struct addrinfo* res = nullptr;
if((stat = getaddrinfo(host.c_str(),
NULL,
&hints,
&res)) != 0) {
std::cerr << "error reading address info: " <<
gai_strerror(stat) << std::endl;
}
saddr.reset(res);
if(saddr->ai_family == AF_INET) {
addr.reset(reinterpret_cast<sockaddr*>(new struct sockaddr_in));
} else if(saddr->ai_family == AF_INET6) {
addr.reset(reinterpret_cast<sockaddr*>(new struct sockaddr_in6));
}
memcpy(addr.get(), saddr->ai_addr, saddr->ai_addrlen);
addrlen = saddr->ai_addrlen;
}
TEST_F(TestString, add4cp) {
unsigned int addr;
unsigned short port;
V4addr saddr("192.168.2.1:4321");
saddr.getAddr(&addr, &port);
ASSERT_EQ(addr, MK_ADDR(192, 168, 2, 1)) << "error ip string4cp constructed object in IP\n";
ASSERT_EQ(port, 4321) << "error ip string4cp object in port\n";
}
TEST_F(TestString, add2d) {
unsigned int addr;
unsigned short port;
V4addr saddr("192.168.");
saddr.getAddr(&addr, &port);
ASSERT_EQ(addr, MK_ADDR(192, 168, 0, 0)) << "error ip string2d constructed object in IP\n";
ASSERT_EQ(port, 0) << "error ip string2d object in port\n";
}
TEST_F(TestString, add3d) {
unsigned int addr;
unsigned short port;
string str;
V4addr saddr("192.168.2.");
saddr.getAddr(&addr, &port);
ASSERT_EQ(addr, MK_ADDR(192, 168, 2, 0)) << "error ip string3d constructed object in IP\n";
ASSERT_EQ(port, 0) << "error ip string3d object in port\n";
saddr.getIPPortString(str);
ASSERT_EQ(0, strcmp("192.168.2.0:0", str.c_str())) << "add3d object address:port mismatch\n";
}
bool
Socket::bind()
{
// host resolution
assert(server);
haddr=INADDR_ANY;
SocketAddress saddr(haddr,iaddr.second);
if (::bind(handle, saddr.getSockAddr(), saddr.getSize()))
{
close();
JGACHINE_SERROR("Can't bind socket");
}
return true;
}
bool
Socket::connect(){
hostent *he_ptr=gethostbyname(iaddr.first.c_str());
if (!he_ptr) JGACHINE_SERROR("Hostname not valid");
EJS_CHECK(he_ptr->h_length==sizeof(haddr));
std::memcpy((char *)&haddr,(char *)he_ptr->h_addr,he_ptr->h_length);
SocketAddress saddr(haddr,iaddr.second);
std::string hstring(saddr.toString());
// EJS_INFO("Connecting to: "<<hstring);
#ifndef JGACHINE_RESTORECONNECT
if (::connect(handle, saddr.getSockAddr(), saddr.getSize())== -1)
#else
if (JGACHINE_RESTORECONNECT(handle, saddr.getSockAddr(), saddr.getSize())== -1)
#endif
{
close();
JGACHINE_SERROR(std::string("Can't connect to ")+hstring);
}
return true;
}
int main(unsigned argc, char** argv)
{
const char* program = argv[0];
const char* address = nullptr;
uint32_t port = 0;
bool commandLineError = false;
for (unsigned i = 1; i < argc; ++i)
{
if (!std::strcmp(argv[i], "-h")
|| !std::strcmp(argv[i], "--help"))
{
Help(program);
return 1;
}
if (!std::strcmp(argv[i], "-a")
|| !std::strcmp(argv[i], "--address"))
{
if (address)
commandLineError = true;
address = argv[++i];
}
else if (!std::strcmp(argv[i], "-p")
|| !std::strcmp(argv[i], "--port"))
{
if (port)
commandLineError = true;
port = std::atoi(argv[++i]);
}
}
if (!address || !port)
{
commandLineError = true;
std::cout << "Please specify a -h/-p combination" << std::endl;
}
if (commandLineError)
{
std::cout << "Command Line Error: Use -h for more info" << std::endl;
return 1;
}
SocketAddress saddr(SocketAddress::FromAddress(address, port));
if (saddr.IsEmpty() || saddr.IsZero())
{
std::cout << "Failed to create a valid socket address from "
<< address << ":" << port << std::endl;
return 1;
}
std::cout << "Initializing socket service" << std::endl;
TCP::SocketServicePtr service(
TCP::SocketService::Factory(TCP::IPv4()));
std::cout << "Attempting to connect to: " << saddr
<< std::endl;
TCP::SocketPtr socket(
service->CreateSocket(saddr));
Client(socket, saddr);
std::cout << "Shutting down socket service" << std::endl;
service->Shutdown();
return 0;
}
//----------------------------------------------------------------------
int idaapi ana(void)
{
//получить один байт
uchar code = ua_next_byte();
switch ( code )
{
//Mnemonic Operand Instruction Code
// B1 B2 B3 B4
case 0x00:
{
//ROR A, 1 0000 0000
cmd.itype = NEC_78K_0S_ror;
cmd.Op1.type = o_reg;
cmd.Op1.reg = rA;
cmd.Op2.type = o_imm;
cmd.Op2.value = 1;
cmd.Op2.regmode = 1;
} break;
case 0x02:
{
//RORC A, 1 0000 0010
cmd.itype = NEC_78K_0S_rorc;
cmd.Op1.type = o_reg;
cmd.Op1.reg = rA;
cmd.Op2.type = o_imm;
cmd.Op2.value = 1;
cmd.Op2.regmode = 1;
} break;
case 0x04:
{
//CLR1 CY 0000 0100
cmd.itype = NEC_78K_0S_clr1;
cmd.Op1.type = o_phrase;
cmd.Op1.reg = bCY;
} break;
case 0x05:
{
//XCH A, saddr 0000 0101 Saddr-offset
cmd.itype = NEC_78K_0S_xch;
cmd.Op1.type = o_reg;
cmd.Op1.reg = rA;
cmd.Op2.type = o_mem;
cmd.Op2.dtyp = dt_byte;
cmd.Op2.addr=saddr(ua_next_byte());
} break;
case 0x06:
{
//NOT1 CY 0000 0110
cmd.itype = NEC_78K_0S_not1;
cmd.Op1.type = o_phrase;
cmd.Op1.reg = bCY;
} break;
case 0x07:
{
//XCH A, sfr 0000 0111 Sfr-offset
cmd.itype = NEC_78K_0S_xch;
cmd.Op1.type = o_reg;
cmd.Op1.reg = rA;
cmd.Op2.type = o_mem;
cmd.Op2.dtyp = dt_byte;
cmd.Op2.addr = sfr(ua_next_byte());
} break;
case 0x08:
{
//NOP 0000 1000
cmd.itype = NEC_78K_0S_nop;
} break;
case 0x0A: // All 0x0A commands
{
uchar code2 = ua_next_byte();
switch ( code2 )
{
case 0x88:
case 0x98:
case 0xA8:
case 0xB8:
case 0xC8:
case 0xD8:
case 0xE8:
case 0xF8:
{
//BT saddr.bit, $addr16 0000 1010 1 B2 B1 B0 1000 Saddr-offset jdisp
cmd.itype = NEC_78K_0S_bt;
cmd.Op1.type = o_bit;
cmd.Op1.dtyp = dt_byte;
cmd.Op1.addr = saddr(ua_next_byte());
cmd.Op1.value = (code2>>4) & 0x07;
jdisp(cmd.Op2, ua_next_byte(), 4);
} break;
case 0x84:
case 0x94:
case 0xA4:
case 0xB4:
case 0xC4:
case 0xD4:
case 0xE4:
case 0xF4:
{
//BT sfr.bit, $addr16 0000 1010 1 B2 B1 B0 0100 Sfr-offset jdisp
//BT PSW.bit, $addr16 0000 1010 1 B2 B1 B0 1000 0001 1110 jdisp
cmd.itype = NEC_78K_0S_bt;
uchar code3 = ua_next_byte();
if ( code3==0x1E )
{
cmd.Op1.type = o_bit;
cmd.Op1.reg = rPSW;
cmd.Op1.value = (code2>>4)&0x07;
jdisp(cmd.Op2, code3, 4);
}
else
{
cmd.Op1.type = o_bit;
cmd.Op1.dtyp = dt_byte;
cmd.Op1.addr = sfr(code3);
cmd.Op1.value = (code2>>4) & 0x07;
jdisp(cmd.Op2, ua_next_byte(), 4);
}
} break;
case 0x08:
case 0x18:
case 0x28:
case 0x38:
case 0x48:
case 0x58:
case 0x68:
case 0x78:
{
//BF saddr.bit, $addr16 0000 1010 0 B2 B1 B0 1000 Saddr-offset jdisp
//BF PSW.bit, $addr16 0000 1010 0 B2 B1 B0 1000 0001 1110 jdisp
cmd.itype = NEC_78K_0S_bf;
uchar code3=ua_next_byte();
if ( code3==0x1E )
{
cmd.Op1.type = o_bit;
cmd.Op1.reg = rPSW;
cmd.Op1.value = (code2>>4)&0x07;
jdisp(cmd.Op2, ua_next_byte(), 4);
}
else
{
cmd.Op1.type = o_bit;
cmd.Op1.dtyp = dt_byte;
cmd.Op1.addr = saddr(code3);
cmd.Op1.value = (code2>>4) & 0x07;
jdisp(cmd.Op2, ua_next_byte(), 4);
}
} break;
U8_EXPORT u8_socket u8_connect_x(u8_string spec,u8_string *addrp)
{
u8_byte _hostname[128], *hostname=_hostname; int portno=-1;
long socket_id;
hostname=u8_parse_addr(spec,&portno,hostname,128);
if (portno<0) return ((u8_socket)(-1));
else if (!(hostname)) return ((u8_socket)(-1));
else if (portno) {
struct sockaddr_in sockaddr;
int addr_len, family=AF_INET;
/* Lookup the host */
char **addrs=u8_lookup_host(hostname,&addr_len,&family), **scan=addrs;
if (addrs==NULL) {
if (hostname!=_hostname) u8_free(hostname);
return -1;}
/* Get a socket */
if ((socket_id=socket(family,SOCK_STREAM,0))<0) {
u8_graberr(-1,"u8_connect:socket",u8_strdup(spec));
u8_free(addrs);
if (hostname!=_hostname) u8_free(hostname);
return ((u8_socket)(-1));}
#if 0
if (timeout>0) {
struct timeval tv;
tv.tv_sec=timeout/1000; tv.tv_usec=(timeout%1000)*1000;
setsockopt(socket_id,level,SO_SNDTIMEO,(void *)&tv,sizeof(struct timeval));
tv.tv_sec=timeout/1000; tv.tv_usec=(timeout%1000)*1000;
setsockopt(socket_id,SO_RCVTIME0,(void *)&tv,sizeof(struct timeval));}
setsockopt(socket_id,SO_NOSIGPIPE,(void *)1,sizeof(int));
#endif
while (*scan) {
char *addr=*scan++;
sockaddr.sin_port=htons((short)portno);
memcpy(&(sockaddr.sin_addr),addr,addr_len);
sockaddr.sin_family=family;
if (connect(socket_id,saddr(sockaddr),sizeof(struct sockaddr_in))<0)
if (*scan==NULL) {
close(socket_id);
u8_free(addrs);
if (hostname!=_hostname) u8_free(hostname);
u8_graberr(-1,"u8_connect:connect",u8_strdup(spec));
return ((u8_socket)(-1));}
else errno=0; /* Try the next address */
else {
if (addrp) *addrp=u8_sockaddr_string((struct sockaddr *)&sockaddr);
if (hostname!=_hostname) u8_free(hostname);
u8_free(addrs);
return (u8_socket)socket_id;}}
u8_free(addrs);
if (hostname!=_hostname) u8_free(hostname);
return ((u8_socket)(-1));}
else {
#if HAVE_SYS_UN_H
struct sockaddr_un sockaddr;
if ((socket_id=socket(PF_LOCAL,SOCK_STREAM,0))<0) {
u8_graberr(-1,"u8_connect:socket",u8_strdup(spec));
if (hostname!=_hostname) u8_free(hostname);
return -1;}
sockaddr.sun_family=AF_UNIX;
strcpy(sockaddr.sun_path,hostname);
if (connect(socket_id,saddr(sockaddr),sizeof(struct sockaddr_un))<0) {
close(socket_id);
u8_graberr(-1,"u8_connect:connect",u8_strdup(spec));
if (hostname!=_hostname) u8_free(hostname);
return ((u8_socket)(-1));}
else return (u8_socket)socket_id;
#else
u8_seterr(NoFileSockets,"u8_connect",NULL);
return ((u8_socket)(-1));
#endif
}
}
int CUploadFreqData::DoUpload()
{
int songid=0;
CAtlString songname;
readOption.Bind(1,L"lastUploadSong");
if(readOption.Step()==SQLITE_ROW)
{
songid=readOption.GetInt(0);
}
readOption.Reset();
getNextSongToUpload.Bind(1,songid);
songid=0;
if(getNextSongToUpload.Step()==SQLITE_ROW)
{
songid=getNextSongToUpload.GetInt(0);
songname=CA2W(getNextSongToUpload.GetText(1),CP_UTF8);
}
getNextSongToUpload.Reset();
std::vector<AnchorInfo> anchorlist;
getAnchorPoint.Bind(1,songid);
while(getAnchorPoint.Step()==SQLITE_ROW)
{
AnchorInfo info;
info.id=getAnchorPoint.GetInt(0);
info.freq=getAnchorPoint.GetInt(1);
info.time=getAnchorPoint.GetInt(2);
anchorlist.push_back(std::move(info));
}
getAnchorPoint.Reset();
if(songid==0)
return 0;
for(auto i=anchorlist.begin();i!=anchorlist.end();++i)
{
getChecker.Bind(1,i->id);
while(SQLITE_ROW==getChecker.Step())
{
CheckInfo cinfo;
cinfo.freq=getChecker.GetInt(0);
cinfo.time_offset=getChecker.GetInt(1);
i->checkinfos.push_back(cinfo);
}
getChecker.Reset();
}
json2::CJsonObject mainobj;
mainobj.Put(L"song",songname);
json2::PJsonArray AnchorList=new json2::CJsonArray();
mainobj.PutValue(L"anchors",AnchorList);
for(auto i=anchorlist.begin();i!=anchorlist.end();++i)
{
json2::PJsonObject anchorObject=new json2::CJsonObject();
AnchorList->PutValue(anchorObject);
anchorObject->Put(L"freq",i->freq);
anchorObject->Put(L"time",i->time);
json2::PJsonArray checkArray=new json2::CJsonArray();
anchorObject->PutValue(L"checks",checkArray);
for(auto j=i->checkinfos.begin();j!=i->checkinfos.end();++j)
{
json2::PJsonObject checker=new json2::CJsonObject();
checkArray->PutValue(checker);
checker->Put(L"freq",j->freq);
checker->Put(L"offset",j->time_offset);
}
}
GZipOutput strout;
mainobj.Save(strout);
strout.Flush();
CSockAddr saddr(L"liveplustest.sinaapp.com",L"80");
HTTPClient::SocketEx socket;
HTTPClient::HttpRequest request("POST","/music/uploadSongFreqData.php");
request.setHost("liveplustest.sinaapp.com");
request.setContentType("gzip/json");
request.setContentLength(strout.memstream->GetBufferSize());
int uploaded_songid=0;
if(0==socket.Connect(saddr.Addr(),saddr.Len()))
{
request.SendRequest(&socket);
socket.Send((const char*)strout.memstream->GetBuffer(),strout.memstream->GetBufferSize());
HTTPClient::HttpResponse response;
if(response.RecvResponseHead(&socket))
{
CComPtr<IMemoryStream> memstream;
CComQIPtr<IStream> outstream;
ByteStream::CreateInstanse(&memstream);
outstream=memstream;
response.RecvResponseBody(&socket,outstream);
json2::PJsonObject resobj;
resobj=json2::CJsonReader::Prase((LPCSTR)memstream->GetBuffer(),(unsigned int)memstream->GetBufferSize());
int server_errno=resobj->GetNumber(L"errno");
CAtlString error=resobj->GetString("error");
json2::PJsonObject data=resobj->Get(L"data");
int server_song_id=data->GetNumber(L"song_id");
CAtlString server_song_name=data->GetString(L"song_name");
if(server_errno==0)
{
uploaded_songid=songid;
writeOption.Bind(1,L"lastUploadSong");
writeOption.Bind(2,songid);
writeOption.Step();
writeOption.Reset();
}
}
}
return uploaded_songid;
}
