// JNI
#include <jni.h>
// NULL
#include <stdio.h>
// va_list, vsnprintf
#include <stdarg.h>
// errno
#include <errno.h>
// strerror_r, memset
#include <string.h>
// socket, bind, getsockname, listen, accept, recv, send, connect
#include <sys/types.h>
#include <sys/socket.h>
 
// sockaddr_un
#include <sys/un.h>
// htons, sockaddr_in
#include <netinet/in.h>
// inet_ntop
#include <arpa/inet.h>
// close, unlink
#include <unistd.h>
// offsetof
#include <stddef.h>
// Max log message length
#define MAX_LOG_MESSAGE_LENGTH 256
// Max data buffer size
#define MAX_BUFFER_SIZE 
 
80
/**
 * Logs the given message to the application.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param format message format and arguments.
 */
static void LogMessage(
        JNIEnv *env,
jobject obj,
const char *format,
...) {
    // Cached log method ID
static jmethodID methodID = NULL
 
;
// If method ID is not cached
if (NULL == methodID) {
        // Get class from object
jclass clazz = env->GetObjectClass(obj);
// Get the method ID for the given method
methodID = env->GetMethodID(clazz, "logMessage",
"(Ljava/lang/String;)V");
// Release the class reference
env->DeleteLocalRef(clazz);
}

    // If method is found
if (NULL != methodID) {
        // Format the log message
char buffer[MAX_LOG_MESSAGE_LENGTH];
va_list ap;
va_start(ap, format);
vsnprintf(buffer, MAX_LOG_MESSAGE_LENGTH, format, ap);
va_end(ap);
// Convert the buffer to a Java string
jstring message = env->NewStringUTF(buffer);
// If string is properly constructed
if (NULL != message) {
            // Log message
env->CallVoidMethod(obj, methodID, message);
// Release the message reference
env->DeleteLocalRef(message);
}
    }
}

/**
 * Throws a new exception using the given exception class
 * and exception message.
 *
 * @param env JNIEnv interface.
 * @param className class name.
 * @param message exception message.
 */
static void ThrowException(
        JNIEnv *env,
const char *className,
const char *message) {
    // Get the exception class
jclass clazz = env->FindClass(className);
// If exception class is found
if (NULL != clazz) {
        // Throw exception
env->ThrowNew(clazz, message);
// Release local class reference
env->DeleteLocalRef(clazz);
}
}

/**
 * Throws a new exception using the given exception class
 * and error message based on the error number.
 *
 * @param env JNIEnv interface.
 * @param className class name.
 * @param errnum error number.
 */
static void ThrowErrnoException(
        JNIEnv *env,
const char *className,
int errnum) {
    char buffer[MAX_LOG_MESSAGE_LENGTH];
// Get message for the error number
if (-1 == strerror_r(errnum, buffer, MAX_LOG_MESSAGE_LENGTH)) {
        strerror_r(errno, buffer, MAX_LOG_MESSAGE_LENGTH);
}

    // Throw exception
ThrowException(env, className, buffer);
}

/**
 * Constructs a new TCP socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewTcpSocket(JNIEnv *env, jobject obj) {
    // Construct socket
LogMessage(env, obj, "Constructing a new TCP socket...");
int tcpSocket = socket(PF_INET, SOCK_STREAM, 0);
// Check if socket is properly constructed
if (-1 == tcpSocket) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
}

    return tcpSocket;
}

/**
 * Binds socket to a port number.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param port port number or zero for random port.
 * @throws IOException
 */
static void BindSocketToPort(
        JNIEnv *env,
jobject obj,
int sd,
unsigned short port) {
    struct sockaddr_in address;
// Address to bind socket
memset(&address, 0, sizeof(address));
address.sin_family = PF_INET;
// Bind to all addresses
address.sin_addr.s_addr = htonl(INADDR_ANY);
// Convert port to network byte order
address.sin_port = htons(port);
// Bind socket
LogMessage(env, obj, "Binding to port %hu.", port);
if (-1 == bind(sd, (struct sockaddr *) &address, sizeof(address))) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
}
}

/**
 * Gets the port number socket is currently binded.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @return port number.
 * @throws IOException
 */
static unsigned short GetSocketPort(
        JNIEnv *env,
jobject obj,
int sd) {
    unsigned short port = 0;
struct sockaddr_in address;
socklen_t addressLength = sizeof(address);
// Get the socket address
if (-1 == getsockname(sd, (struct sockaddr *) &address, &addressLength)) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // Convert port to host byte order
port = ntohs(address.sin_port);
LogMessage(env, obj, "Binded to random port %hu.", port);
}

    return port;
}

/**
 * Listens on given socket with the given backlog for
 * pending connections. When the backlog is full, the
 * new connections will be rejected.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param backlog backlog size.
 * @throws IOException
 */
static void ListenOnSocket(
        JNIEnv *env,
jobject obj,
int sd,
int backlog) {
    // Listen on socket with the given backlog
LogMessage(env, obj,
"Listening on socket with a backlog of %d pending connections.",
backlog);
if (-1 == listen(sd, backlog)) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
}
}

/**
 * Logs the IP address and the port number from the
 * given address.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param message message text.
 * @param address adress instance.
 * @throws IOException
 */
static void LogAddress(
        JNIEnv *env,
jobject obj,
const char *message,
const struct sockaddr_in *address) {
    char ip[INET_ADDRSTRLEN];
// Convert the IP address to string
if (NULL == inet_ntop(PF_INET,
&(address->sin_addr),
ip,
INET_ADDRSTRLEN)) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // Convert port to host byte order
unsigned short port = ntohs(address->sin_port);
// Log address
LogMessage(env, obj, "%s %s:%hu.", message, ip, port);
}
}

/**
 * Blocks and waits for incoming client connections on the
 * given socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @return client socket.
 * @throws IOException
 */
static int AcceptOnSocket(
        JNIEnv *env,
jobject obj,
int sd) {
    struct sockaddr_in address;
socklen_t addressLength = sizeof(address);
// Blocks and waits for an incoming client connection
    // and accepts it
LogMessage(env, obj, "Waiting for a client connection...");
int clientSocket = accept(sd,
(struct sockaddr *) &address,
&addressLength);
// If client socket is not valid
if (-1 == clientSocket) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // Log address
LogAddress(env, obj, "Client connection from ", &address);
}

    return clientSocket;
}

/**
 * Block and receive data from the socket into the buffer.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return receive size.
 * @throws IOException
 */
static ssize_t ReceiveFromSocket(
        JNIEnv *env,
jobject obj,
int sd,
char *buffer,
size_t bufferSize) {
    // Block and receive data from the socket into the buffer
LogMessage(env, obj, "Receiving from the socket...");
ssize_t recvSize = recv(sd, buffer, bufferSize - 1, 0);
// If receive is failed
if (-1 == recvSize) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // NULL terminate the buffer to make it a string
buffer[recvSize] = NULL;
// If data is received
if (recvSize > 0) {
            LogMessage(env, obj, "Received %d bytes: %s", recvSize, buffer);
} else {
            LogMessage(env, obj, "Client disconnected.");
}
    }

    return recvSize;
}

/**
 * Send data buffer to the socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return sent size.
 * @throws IOException
 */
static ssize_t SendToSocket(
        JNIEnv *env,
jobject obj,
int sd,
const char *buffer,
size_t bufferSize) {
    // Send data buffer to the socket
LogMessage(env, obj, "Sending to the socket...");
ssize_t sentSize = send(sd, buffer, bufferSize, 0);
// If send is failed
if (-1 == sentSize) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        if (sentSize > 0) {
            LogMessage(env, obj, "Sent %d bytes: %s", sentSize, buffer);
} else {
            LogMessage(env, obj, "Client disconnected.");
}
    }

    return sentSize;
}

/**
 * Connects to given IP address and given port.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param ip IP address.
 * @param port port number.
 * @throws IOException
 */
static void ConnectToAddress(
        JNIEnv *env,
jobject obj,
int sd,
const char *ip,
unsigned short port) {
    // Connecting to given IP address and given port
LogMessage(env, obj, "Connecting to %s:%uh...", ip, port);
struct sockaddr_in address;
memset(&address, 0, sizeof(address));
address.sin_family = PF_INET;
// Convert IP address string to Internet address
if (0 == inet_aton(ip, &(address.sin_addr))) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // Convert port to network byte order
address.sin_port = htons(port);
// Connect to address
if (-1 == connect(sd, (const sockaddr *) &address, sizeof(address))) {
            // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
            LogMessage(env, obj, "Connected.");
}
    }
}

void Java_com_apress_echo_EchoClientActivity_nativeStartTcpClient(
        JNIEnv *env,
jobject obj,
jstring ip,
jint port,
jstring message) {
    // Construct a new TCP socket.
int clientSocket = NewTcpSocket(env, obj);
if (NULL == env->ExceptionOccurred()) {
        // Get IP address as C string
const char *ipAddress = env->GetStringUTFChars(ip, NULL);
if (NULL == ipAddress)
            goto exit;
// Connect to IP address and port
ConnectToAddress(env, obj, clientSocket, ipAddress,
(unsigned short) port);
// Release the IP address
env->ReleaseStringUTFChars(ip, ipAddress);
// If connection was successful
if (NULL != env->ExceptionOccurred())
            goto exit;
// Get message as C string
const char *messageText = env->GetStringUTFChars(message, NULL);
if (NULL == messageText)
            goto exit;
// Get the message size
jsize messageSize = env->GetStringUTFLength(message);
// Send message to socket
SendToSocket(env, obj, clientSocket, messageText, messageSize);
// Release the message text
env->ReleaseStringUTFChars(message, messageText);
// If send was not successful
if (NULL != env->ExceptionOccurred())
            goto exit;
char buffer[MAX_BUFFER_SIZE];
// Receive from the socket
ReceiveFromSocket(env, obj, clientSocket, buffer, MAX_BUFFER_SIZE);
}

    exit:
    if (clientSocket > 0) {
        close(clientSocket);
}
}

void Java_com_apress_echo_EchoServerActivity_nativeStartTcpServer(
        JNIEnv *env,
jobject obj,
jint port) {
    // Construct a new TCP socket.
int serverSocket = NewTcpSocket(env, obj);
if (NULL == env->ExceptionOccurred()) {
        // Bind socket to a port number
BindSocketToPort(env, obj, serverSocket, (unsigned short) port);
if (NULL != env->ExceptionOccurred())
            goto exit;
// If random port number is requested
if (0 == port) {
            // Get the port number socket is currently binded
GetSocketPort(env, obj, serverSocket);
if (NULL != env->ExceptionOccurred())
                goto exit;
}

        // Listen on socket with a backlog of 4 pending connections
ListenOnSocket(env, obj, serverSocket, 4);
if (NULL != env->ExceptionOccurred())
            goto exit;
// Accept a client connection on socket
int clientSocket = AcceptOnSocket(env, obj, serverSocket);
if (NULL != env->ExceptionOccurred())
            goto exit;
char buffer[MAX_BUFFER_SIZE];
ssize_t recvSize;
ssize_t sentSize;
// Receive and send back the data
while (1) {
            // Receive from the socket
recvSize = ReceiveFromSocket(env, obj, clientSocket,
buffer, MAX_BUFFER_SIZE);
if ((0 == recvSize) || (NULL != env->ExceptionOccurred()))
                break;
// Send to the socket
sentSize = SendToSocket(env, obj, clientSocket,
buffer, (size_t) recvSize);
if ((0 == sentSize) || (NULL != env->ExceptionOccurred()))
                break;
}

        // Close the client socket
close(clientSocket);
}

    exit:
    if (serverSocket > 0) {
        close(serverSocket);
}
}

/**
 * Constructs a new UDP socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewUdpSocket(JNIEnv *env, jobject obj) {
    // Construct socket
LogMessage(env, obj, "Constructing a new UDP socket...");
int udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
// Check if socket is properly constructed
if (-1 == udpSocket) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
}

    return udpSocket;
}

/**
 * Block and receive datagram from the socket into
 * the buffer, and populate the client address.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param address client address.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return receive size.
 * @throws IOException
 */
static ssize_t ReceiveDatagramFromSocket(
        JNIEnv *env,
jobject obj,
int sd,
struct sockaddr_in *address,
char *buffer,
size_t bufferSize) {
    socklen_t addressLength = sizeof(struct sockaddr_in);
// Receive datagram from socket
LogMessage(env, obj, "Receiving from the socket...");
ssize_t recvSize = recvfrom(sd, buffer, bufferSize, 0,
(struct sockaddr *) address,
&addressLength);
// If receive is failed
if (-1 == recvSize) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else {
        // Log address
LogAddress(env, obj, "Received from", address);
// NULL terminate the buffer to make it a string
buffer[recvSize] = NULL;
// If data is received
if (recvSize > 0) {
            LogMessage(env, obj, "Received %d bytes: %s", recvSize, buffer);
}
    }

    return recvSize;
}

/**
 * Sends datagram to the given address using the given socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @param sd socket descriptor.
 * @param address remote address.
 * @param buffer data buffer.
 * @param bufferSize buffer size.
 * @return sent size.
 * @throws IOException
 */
static ssize_t SendDatagramToSocket(
        JNIEnv *env,
jobject obj,
int sd,
const struct sockaddr_in *address,
const char *buffer,
size_t bufferSize) {
    // Send data buffer to the socket
LogAddress(env, obj, "Sending to", address);
ssize_t sentSize = sendto(sd, buffer, bufferSize, 0,
(const sockaddr *) address,
sizeof(struct sockaddr_in));
// If send is failed
if (-1 == sentSize) {
        // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
} else if (sentSize > 0) {
        LogMessage(env, obj, "Sent %d bytes: %s", sentSize, buffer);
}

    return sentSize;
}

void Java_com_apress_echo_EchoClientActivity_nativeStartUdpClient(
        JNIEnv *env,
jobject obj,
jstring ip,
jint port,
jstring message) {
    // Construct a new UDP socket.
int clientSocket = NewUdpSocket(env, obj);
if (NULL == env->ExceptionOccurred()) {
        struct sockaddr_in address;
memset(&address, 0, sizeof(address));
address.sin_family = PF_INET;
// Get IP address as C string
const char *ipAddress = env->GetStringUTFChars(ip, NULL);
if (NULL == ipAddress)
            goto exit;
// Convert IP address string to Internet address
int result = inet_aton(ipAddress, &(address.sin_addr));
// Release the IP address
env->ReleaseStringUTFChars(ip, ipAddress);
// If conversion is failed
if (0 == result) {
            // Throw an exception with error number
ThrowErrnoException(env, "java/io/IOException", errno);
goto exit;
}

        // Convert port to network byte order
address.sin_port = htons(port);
// Get message as C string
const char *messageText = env->GetStringUTFChars(message, NULL);
if (NULL == messageText)
            goto exit;
// Get the message size
jsize messageSize = env->GetStringUTFLength(message);
// Send message to socket
SendDatagramToSocket(env, obj, clientSocket, &address,
messageText, messageSize);
// Release the message text
env->ReleaseStringUTFChars(message, messageText);
// If send was not successful
if (NULL != env->ExceptionOccurred())
            goto exit;
char buffer[MAX_BUFFER_SIZE];
// Clear address
memset(&address, 0, sizeof(address));
// Receive from the socket
ReceiveDatagramFromSocket(env, obj, clientSocket, &address,
buffer, MAX_BUFFER_SIZE);
}

    exit:
    if (clientSocket > 0) {
        close(clientSocket);
}
}

void Java_com_apress_echo_EchoServerActivity_nativeStartUdpServer(
        JNIEnv *env,
jobject obj,
jint port) {
    // Construct a new UDP socket.
int serverSocket = NewUdpSocket(env, obj);
if (NULL == env->ExceptionOccurred()) {
        // Bind socket to a port number
BindSocketToPort(env, obj, serverSocket, (unsigned short) port);
if (NULL != env->ExceptionOccurred())
            goto exit;
// If random port number is requested
if (0 == port) {
            // Get the port number socket is currently binded
GetSocketPort(env, obj, serverSocket);
if (NULL != env->ExceptionOccurred())
                goto exit;
}

        // Client address
struct sockaddr_in address;
memset(&address, 0, sizeof(address));
char buffer[MAX_BUFFER_SIZE];
ssize_t recvSize;
ssize_t sentSize;
// Receive from the socket
recvSize = ReceiveDatagramFromSocket(env, obj, serverSocket,
&address, buffer, MAX_BUFFER_SIZE);
if ((0 == recvSize) || (NULL != env->ExceptionOccurred()))
            goto exit;
// Send to the socket
sentSize = SendDatagramToSocket(env, obj, serverSocket,
&address, buffer, (size_t) recvSize);
}

    exit:
    if (serverSocket > 0) {
        close(serverSocket);
}
}

/**
 * Constructs a new Local UNIX socket.
 *
 * @param env JNIEnv interface.
 * @param obj object instance.
 * @return socket descriptor.
 * @throws IOException
 */
static int NewLocalSocket(JNIEnv *env, jobject obj) {
    // Construct socket
LogMessage(env, obj, "Constructing a new Local UNIX socket...");
int localSocket = socket(PF_LOCAL, SOCK_STREAM, 0);
// Check if socket is properly constructed
if (-1 == localSocket) {
        // Throw an exception with error number
 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
TCP/UDP/LOCAL Socket C++的實現
     
 
// JNI
#include <jni.h>
// NULL
#include <stdio.h>
// va_list, vsnprintf
#include <stdarg.h>
// errno
#include <errno.h>
// strerr 

  
 

    

    
    
**c++基於tcp協議的socket程式設計實現一個簡單伺服器**
     
  
  
  
 c++基於tcp協議的socket程式設計實現一個簡單伺服器 基於tcp的通訊，可以利益socket套接字實現。通訊，顧名思義需要伺服器和客戶端兩者進行資訊互動。  通過流程圖我們可以看到程式設計實現伺服器和客戶端的步驟大致相同，而伺服器則更為複雜一些。本文之給出了一個簡單的伺服器程式設計和 

  
 

    

    
    
Java：基於TCP協議網路socket程式設計(實現C/S通訊)
     
 目錄
一、前言：TCP原理簡介
二、Socket程式設計通訊
三、TCP伺服器端（具體程式碼）
四、TCP客戶端（具體程式碼）
五、通訊效果演示
六、“創意”機器人：價值一個億的AI核心程式碼（具體程式碼）
七、最後

 
一、前言：TCP原理簡介
首先，保證文章完整性，TC 

  
 

    

    
    
網路通訊協議和 tcp udp在 socket 中的區別 網路通訊協議
     
 
  
 
 
  
   
    
     
      
      網路通訊協議 
      
        
       
       
        
        本節主要內容： 
        1.osi七層模型 
        2.socket 
    

  
 

    

    
    
說說TCP,UDP和socket,Http之間聯絡和區別
     
 
							
							
							整理的這些區別和聯絡都是非常重要的。

TCP協議 
TCP（Transmission Control Protocol 傳輸控制協議）是一種面向連線的、可靠的、基於位元組流的傳輸層通訊協議，由IETF的RFC 793定義。在簡化的計算機網路OSI模型中，它完成 

  
 

    

    
    
基於TCP協議的Socket通訊 實現使用者登入 以及服務端的相應
     
 
								
								            
						
                


服務端


package com.example;
import java.io.BufferedReader;
import java.io.IOException;
import java. 

  
 

    

    
    
TCP,UDP和socket，Http之間的聯絡與區別
     
 
							
							
							因為最近做一個智慧家居專案，首先要通訊用socket，為了及時先用UDP判斷是內網外網建立連結，再用TCP實時通訊。



首先了解定義





TCP的優點：

可靠，穩定 
TCP的可靠體現在TCP在傳遞資料之前，會有三次握手來建立連線，而且在資料傳遞時， 

  
 

    

    
    
基於TCP/UDP的socket程式設計流程
     
 
                其實Socket程式設計也對應於TCP和UDP的通訊機制：

這裡附上TCP/UDP通訊機制的圖例，對應他們建立通訊的過程，就很容易理解Socket是如何進行通訊的了：





基於TCP(面向連線)的socket程式設計的伺服器端程式如下：

1、建立套接字（socket 

  
 

    

    
    
Windows socket c++ TCP UDP 簡單客戶端 vs2013
     
 進行   msg   print   type   pro   i/o   while   write   n)   socket 主要是網絡中進程之間的通信，起源於Unix，而“一切皆可文件”的思想一樣可以用在socket上，即 打開 -> 讀寫 -> 關閉。
int socket(int do 

  
 

    

    
    
Untiy中用C#實現TCP通訊（Socket通訊）服務端與客戶端皆可
     
  
 
 簡而言之，TCP通訊原理大家可以從各種網路文獻上找到，這裡不做贅述。 
 只提出C#實現TCP通訊的一般方法和常用程式碼工具供第一次接觸TCP通訊的玩家參考，老玩家繞道。。。 
 為了方便大家理解我的程式碼，會適當提及通訊遠離。 
  
 1、建立服務端，TCP連線的基本： 
  
 using U 

  
 

    

    
    
C語言 AF_UNIX tcp/udp socket例項
     
  
 
 https://blog.csdn.net/shanzhizi/article/details/16882087 
   
 ========================tcp 方式============================ 
 伺服器端： 
     //s_unix. 

  
 

    

    
    
C++:實現socket通訊（TCP/IP）例項
     
 
                       首先宣告，博主之前從來沒有寫過通訊方面的東西，這次之所以寫這個是因為專案需要，因此本文主要介紹一個使用C++語言及Socket來實現TCP/IP通訊的例項，希望可以幫助入門者。

一、什麼是TCP/IP？

        TCP提供基於IP環境下的資料可靠性傳 

  
 

    

    
    
Java Socket通訊及TCP/UDP實現
     
 
								
								            
							
							
							 
記得上一次接觸socket這一塊還是在大三抓耳撓腮的整畢設的時候，兩年後的今天又用到了它，那就把Socket實現組播什麼的做一個記錄吧。 


TcpServer



public class T 

  
 

    

    
    
python socket實現簡單的(TCP/UDP)伺服器/客戶端
     
 
								
								            
						
                
1、建立TCP服務端

# -*- coding: utf-8 -*-   
from socket import *  
from time import ctime  
  
HOST = 'lo 

  
 

    

    
    
python基礎之socket編程-------基於tcp的套接字實現遠程執行命令的操作
     
 logs   lose   stream   res   std   遠程控制   python   log   out   遠程實現cmd功能：
 


import socket
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOC 

  
 

    

    
    
[C# 網絡編程系列]專題七：UDP編程補充——UDP廣播程序的實現
     
 tca   ssa   程序   als   learn   ans   targe   focus   ase   上次因為時間的關系，所以把上一個專題遺留下的一個問題在本專題中和大家分享下，本專題主要介紹下如何實現UDP廣播的程序，下面就直接介紹實現過程和代碼以及運行的結果。
一、程序實現
UDP廣播程序 

  
 

    

    
    
Linux c實現一個tcp文件服務器和客戶端
     
 repr   snippets   功能   stderr   strcpy   fprintf   inet_addr   編寫   create   總體需求：編寫tcp文件服務器和客戶端。客戶端可以上傳和下載文件。

=========================================== 

  
 

    

    
    
SOCKET, TCP/UDP, HTTP, FTP 淺析
     
 net   telnet   應用層   base   中間節點   簡單網絡管理協議   sock   協議   主動   
SOCKET， TCP/UDP, HTTP, FTP
  
（一）TCP/UDP,SOCKET,HTTP,FTP簡析

 




TCP/IP是個協議組，可分為三個層次：網絡層、傳 

  
 

    

    
    
TCP,UDP,HTTP,IP,SOCKET
     
 限制   -c   開始   java.net   現在   認識   sock   特性   鏈接   近日對各網絡協議進行了一番學習，宏觀認識上有收獲。
網絡由下往上分為物理層、數據鏈路層、網絡層、傳輸層、會話層、表示層和應用層。（引用）IP 協議對應於網絡層，TCP/UDP協議對應於傳輸層，
HTTP協 

  
 

    

    
    
T-Pot平臺Honeytrap蜜罐TCP/UDP服務攻擊探測及實現自動化郵件告警
     
 協議   image   日誌記錄   nbsp   ash   boa   模擬   記錄   文件   T-pot平臺的Honeytrap可觀察針對TCP或UDP服務的攻擊，作為一個守護程序模擬一些知名的服務，並能夠分析攻擊字符串，執行相應的下載文件指令，當不產生TCP或者UDP協議的時候Honeytra