static int module7_init(void)
{
int port= 13394;
struct socket* serversocket;
struct socket* newsocks;
size_t recieving, lens;
char * Buffer;
Buffer = (char*)__get_free_page(GFP_KERNEL);
lens=strlen(Buffer);
serversocket= set_up_server_socket(port);
do{
newsocks= server_accept_connection(serversocket);
recieving = RecvBuffer(newsocks, Buffer, lens);
if (recieving<=0)
{
printk(KERN_INFO "Server:error when receiving message");
}
else
{
printk(KERN_INFO "Server received msg: %s",Buffer);
}
}while(1);
return 0;
}
DWORD recv_cjhb::ThreadProc(void)
{
int exit_code=0;
clhb_ans ca;
while(this->IsRunning())
{
//recv cjhb
if(RecvBuffer((char*)&ca,sizeof(ca)))
{
//invoke OnRecvCJHB
OnRecvCJHB(&(ca.cr));
}
else
{
exit_code=-1;
break;
}
}
//invoke OnTerminate
OnTerminate(exit_code);
Disconnect();
return 0;
}
bool RecvFileStream( SOCKET sock, FILE* pf, unsigned long flsize, int nBufSize )
{
ASSERT( NULL!=pf );
//receive the file content.
unsigned long lAvailBytes = flsize;
char* pBuf = new char[nBufSize];
try{
while( lAvailBytes>0 && !ferror(pf) ){
int nAvailBuf = min( (unsigned long)nBufSize, lAvailBytes );
RecvBuffer( sock, pBuf, nAvailBuf );
fwrite( pBuf, 1, nAvailBuf, pf );
lAvailBytes -= nAvailBuf;
}
}catch( CSockException* ){
delete[] pBuf;
pBuf = NULL;
throw;
}
delete[] pBuf;
pBuf = NULL;
return !ferror( pf );
}
static int module7_init(void)
{
int port= 13394;
size_t recieving;
struct netlink_kernel_cfg cfg = {
.groups = 1,
.input = netlinkmsg,
};
nl_sk = netlink_kernel_create(&init_net, 3, &cfg);
Buffer = (char*)__get_free_page(GFP_KERNEL);
serversocket= set_up_server_socket(port);
newsocks= server_accept_connection(serversocket);
recieving = RecvBuffer(newsocks, Buffer, 1024);
if (recieving<=0)
{
printk(KERN_INFO "Server:error when receiving message\n");
}
else
{
printk(KERN_INFO "Server received msg: %s \n",Buffer);
}
file1 = debugfs_create_file("mmap_example1", 0644, NULL, NULL, &my_fops);
if (file1 == NULL)
{
printk(KERN_ALERT "Error occurred\n");
}
else
{
printk("The creation of the file should has occured\n");
printk("The pointer value of the create file %p \n", &file1);
}
return 0;
}
static void module7_exit(void)
{
sock_release(serversocket);
sock_release(newsocks);
debugfs_remove(file1);
netlink_kernel_release(nl_sk);
printk(KERN_ALERT "Server exiting \n");
return;
}
HRESULT CClientSession::DoListDir( const string& strPath, EnumNetfEntryProc pEnumProc )
{
//step 1. request passive mode to get the data channel address
u_int nPasPort = 0;
HRESULT hRet = DoPassive( nPasPort );
if( FAILED(hRet) )return hRet;
//step 2. send the put file command.
CMessage1Param<char*>* pMsgList = (CMessage1Param<char*>*)CMessageBase::Alloc( sizeof(CMessageBase)+strPath.length()+1 );
pMsgList->Init( NCM_LISTDIR, GetAddr(), GetServAddr(), strPath.c_str() );
CMessageTrash trash1(pMsgList);
m_pClntProxy->SendMessage( pMsgList );
CMessageBase* pMsgAck = WaitForMessage( NCF_ACK|NCM_LISTDIR );
CMessageTrash trash2(pMsgAck);
if( !pMsgAck->IsSucceeded() )return pMsgAck->GetResult();
//step 3. now the server agrees on the file transfer, connect the data channel and send file
SOCKET sock_stream = OpenStream( nPasPort );
if( sock_stream==INVALID_SOCKET )return E_OPENSTREAM;
//open the data stream channel.
/* CMessageBase msg;
msg.Init( NCM_OPENSTREAM, GetAddr(), GetServAddr() );
SendMessage( sock_stream, &msg );
CMessageBase* pMsg = RecvMessage<CMessageBase>( sock_stream );
if( pMsg==NULL ){
closesocket( sock_stream );
return E_OPENSTREAM;
}
CMessageTrash trash3(pMsg);
if( pMsg->IsFailed() ){
closesocket( sock_stream );
return pMsg->GetResult();
}*/
NETF_ENTRY entry;
int nLen = 0;
while( true ){
if( RecvBuffer( sock_stream, (char*)&entry, sizeof(NETF_ENTRY) )<sizeof(NETF_ENTRY) )break;
(*pEnumProc)( &entry );
nLen += sizeof(NETF_ENTRY);
}
closesocket( sock_stream );
//step 4. exchange the error code.
CMessageBase msg;
msg.Init( NCM_STREAMLENGTH, GetAddr(), GetServAddr(), nLen );
m_pClntProxy->SendMessage( &msg );
CMessageBase* pMsg = WaitForMessage( NCF_ACK|NCM_STREAMLENGTH );
CMessageTrash trash4(pMsg);
return pMsg->GetResult();
}
//*=================================================================================
//*原型: bool ReadRequestPacket(TSmartPacket& Packet)
//*功能: 接求一个请求包
//*参数: 无
//*返回: 无
//*说明: 无
//*=================================================================================
bool TSmartOutThread::ReadRequestPacket(SOCKET hSocket, TSmartPacket& Packet)
{
//读入包头数据
long nLength = sizeof(TSSmartPacket);
long nRecvLen = RecvBuffer(hSocket, Packet.GetBuffer(), nLength, 1000);
TSSmartPacket *pPacket = (TSSmartPacket*)Packet.GetBuffer();
if( nRecvLen != nLength )
{
// ReportLog("包头长度不对! 读入的数据包不合法!");
return false;
}
nLength = Packet.GetDataLength() + 1 ;
if( nLength > 0 )
{
if( RecvBuffer(hSocket, Packet.GetDataBuffer(), nLength, 1000) != nLength )
{
// printf("不能接收包内的数据!\n");
DebugPrint("不能接收包内的数据!");
return false;
}
nRecvLen+=nLength;
}
ReportLog("读入数据包:[%s]\n", Packet.m_Buffer);
if( !Packet.IsValid(nRecvLen) )
{
// printf("包头校验错!读入的数据包不合法!\n");
DebugPrint("读入的数据包不合法!");
return false;
}
return true;
}
int main()
{
struct sockaddr_in serveraddr;
int sock = -1;
int err = 0;
char buffer[BUFFER_SIZE];
do {
memset(&serveraddr,0,sizeof(serveraddr));
serveraddr.sin_addr.s_addr=inet_addr("127.0.0.1");
serveraddr.sin_port=htons(8887);
serveraddr.sin_family=AF_INET;
sock = socket(AF_INET,SOCK_STREAM,0);
if ( -1 == sock ) {
debug_log("create socket failed",errno);
break;
}
err = connect(sock,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
if ( 0 != err ) {
debug_log("connect server failed",err);
break;
}
/**
*连接成功，发送消息，接受消息
*/
printf("please input the message:");
scanf("%s",buffer);
err = SendBuffer(sock,buffer);
if ( 0 != err ) {
break;
}
err = RecvBuffer(sock,buffer);
if ( 0 != err ) {
break;
}
} while(0);
if ( -1 != sock ) {
close(sock);
sock = -1;
}
return err;
}
static int module7_init(void)
{
int port= 13394;
unsigned int IP_addr= 168430083;
size_t sendings;
char *sendbuff;
struct socket* serversock;
struct socket* newsocket;
size_t recieve;
size_t length;
size_t lens;
char *recvbuffer;
recvbuffer = (char*)__get_free_page(GFP_KERNEL);
sendbuff= "hi i am thinh";
//file1 = debugfs_create_file("mmap_example1", 0644, NULL, NULL, &my_fops);
/*
//setup_timer(&my_timer, my_timer_callback, 0 );
if (file1 == NULL)
{
printk(KERN_ALERT "Error occurred\n");
}
else
{
printk("The creation of the file should has occured\n");
printk("The pointer value of the create file %p \n", &file1);
}
*/ lens = strlen(recvbuffer);
serversock=set_up_server_socket(port);
do{
newsocket = server_accept_connection(serversock);
recieve = RecvBuffer(newsocket, recvbuffer, lens);
if (recieve <= 0)
{
printk("Client Error when recieving msg");
break;
}
else
{
printk("ClientMSG recieved: %s \n", recvbuffer);
}
}while(1);
socketz=set_up_client_socket(IP_addr,port);
length=strlen(sendbuff);
sendings= SendBuffer(socketz, sendbuff, length);
sock_release(newsocket);
sock_release(socketz);
return 0;
}
static int module7_init(void)
{
int port= 13394;
unsigned int IP_addr= 3232250007;
// int ret=25;
// int ret2=0;
size_t sendings;
size_t recievedmsg;
char *sendbuff;
char *recvbuff;
size_t length;
size_t lens2;
int i;
recvbuff= (char*)__get_free_page(GFP_KERNEL);
lens2=20;
sendbuff= "Client: please put this in send mmap_example1";
socketz=set_up_client_socket(IP_addr,port);
//length=strlen(sendbuff);
length=45;
sendings= SendBuffer(socketz, sendbuff, length);
for (i=0;i<5;i++)
{
recievedmsg=RecvBuffer(socketz,recvbuff,lens2);
if(recievedmsg<0)
{
printk("could not recieve msg\n");
}
else
{
recvbuff= kmalloc(sizeof(recvbuff),GFP_KERNEL);
// lens2=strlen(recvbuff);
}
}
return 0;
}
/*!
Set the recevies in "continuous" mode.
When the recives are in "continuous" mode they will be restarted as soon
as they end. In this way there is always a buffer ready for receiveing
data.
Calling this function will cancels all current receives.
\param enabled if set to true enables the "continuous" mode.
*/
void DataCommunicator::setRecvsContinuous(bool enabled)
{
if (m_recvsContinuous == enabled) {
return;
}
cancelAllRecvs();
int nRecvBuffers = m_recvBuffers.size();
for (int k = 0; k < nRecvBuffers; ++k) {
size_t capacity = m_recvBuffers[k].capacity();
m_recvBuffers[k] = RecvBuffer(capacity, enabled);
}
m_recvsContinuous = enabled;
startAllRecvs();
}
//Send DNS requesting process
size_t __fastcall SendProcess(const sockaddr_storage Target)
{
//Initialization
std::shared_ptr<char> Buffer(new char[BufferSize]()), RecvBuffer(new char[BufferSize]());
SSIZE_T DataLength = 0;
LARGE_INTEGER CPUFrequency = {0}, BeforeTime = {0}, AfterTime = {0};
SOCKET Socket = 0;
int AddrLen = 0;
//IPv6
if (Protocol == AF_INET6)
{
//Socket initialization
AddrLen = sizeof(sockaddr_in6);
if (RawSocket && RawData)
Socket = socket(AF_INET6, SOCK_RAW, ServiceName);
else
Socket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (Socket == INVALID_SOCKET)
{
wprintf(L"Socket initialization error, error code is %d.\n", WSAGetLastError());
WSACleanup();
return EXIT_FAILURE;
}
}
//IPv4
else {
//Socket initialization
AddrLen = sizeof(sockaddr_in);
if (RawSocket && RawData)
Socket = socket(AF_INET, SOCK_RAW, ServiceName);
else
Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (Socket == INVALID_SOCKET)
{
wprintf(L"Socket initialization error, error code is %d.\n", WSAGetLastError());
WSACleanup();
return EXIT_FAILURE;
}
}
//Set socket timeout.
if (setsockopt(Socket, SOL_SOCKET, SO_SNDTIMEO, (PSTR)&SocketTimeout, sizeof(int)) == SOCKET_ERROR ||
setsockopt(Socket, SOL_SOCKET, SO_RCVTIMEO, (PSTR)&SocketTimeout, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set UDP socket timeout error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
//Set IP options.
if (Protocol == AF_INET6) //IPv6
{
if (IP_HopLimits != 0 && setsockopt(Socket, IPPROTO_IP, IPV6_UNICAST_HOPS, (PSTR)&IP_HopLimits, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set HopLimit/TTL flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
}
else { //IPv4
if (IP_HopLimits != 0 && setsockopt(Socket, IPPROTO_IP, IP_TTL, (PSTR)&IP_HopLimits, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set HopLimit/TTL flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
//Set "Don't Fragment" flag.
int iIPv4_DF = 1;
if (IPv4_DF && setsockopt(Socket, IPPROTO_IP, IP_DONTFRAGMENT, (PSTR)&iIPv4_DF, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set \"Don't Fragment\" flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
}
//Make packet.
if (!RawData)
{
//DNS requesting
memcpy(Buffer.get() + DataLength, &HeaderParameter, sizeof(dns_hdr));
if (HeaderParameter.ID == 0)
{
auto pdns_hdr = (dns_hdr *)(Buffer.get() + DataLength);
pdns_hdr->ID = htons((uint16_t)GetCurrentProcessId());
}
DataLength += sizeof(dns_hdr);
DataLength += CharToDNSQuery((PSTR)TestDomain.c_str(), Buffer.get() + DataLength);
memcpy(Buffer.get() + DataLength, &QueryParameter, sizeof(dns_qry));
DataLength += sizeof(dns_qry);
if (EDNS0)
{
memcpy(Buffer.get() + DataLength, &EDNS0Parameter, sizeof(dns_edns0_label));
DataLength += sizeof(dns_edns0_label);
}
}
else {
if (BufferSize >= RawDataLen)
{
memcpy(Buffer.get(), RawData.get(), RawDataLen);
DataLength = RawDataLen;
}
else {
memcpy(Buffer.get(), RawData.get(), BufferSize);
DataLength = BufferSize;
}
}
//Send.
if (QueryPerformanceFrequency(&CPUFrequency) == 0 || QueryPerformanceCounter(&BeforeTime) == 0)
{
wprintf(L"Get current time form High Precision Event Timer/HPET error, error code is %d.\n", (int)GetLastError());
return EXIT_FAILURE;
}
sendto(Socket, Buffer.get(), (int)DataLength, NULL, (PSOCKADDR)&Target, AddrLen);
//Receive.
DataLength = recvfrom(Socket, RecvBuffer.get(), (int)BufferSize, NULL, (PSOCKADDR)&Target, &AddrLen);
if (QueryPerformanceCounter(&AfterTime) == 0)
{
wprintf(L"Get current time form High Precision Event Timer/HPET error, error code is %d.\n", (int)GetLastError());
return EXIT_FAILURE;
}
//Get waiting time.
long double Result = (long double)((AfterTime.QuadPart - BeforeTime.QuadPart) * (long double)1000 / (long double)CPUFrequency.QuadPart);
//Print to screen.
if (DataLength > 0)
{
wprintf(L"Receive from %ls:%u -> %d bytes, waiting %lf ms.\n", wTargetString.c_str(), ntohs(ServiceName), (int)DataLength, Result);
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L"Receive from %ls:%u -> %d bytes, waiting %lf ms.\n", wTargetString.c_str(), ntohs(ServiceName), (int)DataLength, Result);
TotalTime += Result;
RecvNum++;
//Mark time.
if (MaxTime == 0)
{
MinTime = Result;
MaxTime = Result;
}
else if (Result < MinTime)
{
MinTime = Result;
}
else if (Result > MaxTime)
{
MaxTime = Result;
}
//Transmission interval
if (TransmissionInterval != 0 && TransmissionInterval > Result)
Sleep((DWORD)(TransmissionInterval - Result));
else
Sleep(TIME_OUT - (DWORD)Result);
}
else { //SOCKET_ERROR
wprintf(L"Receive error: %d(%d), waiting %lf ms.\n", (int)DataLength, WSAGetLastError(), Result);
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L"Receive error: %d(%d), waiting %lf ms.\n", (int)DataLength, WSAGetLastError(), Result);
//Transmission interval
if (TransmissionInterval != 0 && TransmissionInterval > Result)
Sleep((DWORD)(TransmissionInterval - Result));
else if (Result <= TIME_OUT)
Sleep(TIME_OUT);
}
return EXIT_SUCCESS;
}
HRESULT CClientSession::DoListDir( const string& strPath, EnumNetfEntryProc pEnumProc )
{
//step 1. request passive mode to get the data channel address
u_int nPasPort = 0;
HRESULT hRet = DoPassive( nPasPort );
if( FAILED(hRet) )return hRet;
//step 2. send the put file command.
CMessageHead* pMsg = (CMessageHead*)new char[sizeof(CMessageHead)+strPath.length()+1];
pMsg->Init( NCM_LISTDIR, GetAddr(), GetServAddr() );
pMsg->SetLength( sizeof(CMessageHead)+strPath.length()+1 );
strcpy( pMsg->GetData(), strPath.c_str() );
m_pClntProxy->SendMessage( pMsg );
CMessageHead* pMsgAck = GetMessage( NCF_ACK|NCM_LISTDIR );
CMessageTrash trash(pMsgAck);
if( !pMsgAck->IsSucceeded() )return pMsgAck->GetResult();
//step 3. now the server agrees on the file transfer, connect the data channel and send file
SOCKADDR_IN addr;
addr.sin_family = AF_INET;
addr.sin_addr = GetServAddr().m_addrHost;
addr.sin_port = htons( (u_short)nPasPort );
SOCKET sock_stream;
//import, must retry the socket initilization a few times.
int i;
for( i=0; i<MAXRETRY; i++ ){
sock_stream = Socket( PF_INET, SOCK_STREAM, 0 );
ASSERT( sock_stream!=INVALID_SOCKET );
if( ::connect( sock_stream, (SOCKADDR*)&addr, sizeof(SOCKADDR_IN) )==0 )break;
closesocket( sock_stream );
}
if( i>=MAXRETRY )throw new CSockException();
//open the data stream channel.
CMessageHead msg;
msg.Init( NCM_OPENSTREAM, GetAddr(), GetServAddr() );
msg.Send( sock_stream );
pMsg = RecvMessage( sock_stream );
CMessageTrash trash2(pMsg);
if( pMsg->IsFailed() ){}
NETF_ENTRY entry;
int nLen = 0;
while( true ){
try{
RecvBuffer( sock_stream, (char*)&entry, sizeof(NETF_ENTRY) );
}catch( CSockException* e ){
e->Delete();
break;
}
(*pEnumProc)( &entry );
nLen += sizeof(NETF_ENTRY);
}
closesocket( sock_stream );
//step 4. exchange the error code.
msg.Init( NCM_STREAMLENGTH, GetAddr(), GetServAddr(), nLen );
m_pClntProxy->SendMessage( &msg );
pMsg = GetMessage( NCF_ACK|NCM_STREAMLENGTH );
CMessageTrash trash3(pMsg);
return pMsg->GetResult();
}
void RecvNetfStat( SOCKET sock, PNETF_STAT pStat )
{
RecvBuffer( sock, (char*)pStat, sizeof(NETF_STAT) );
}
