安全传输平台项目——统一通信组件-统一共享内存组件

最新推荐文章于 2022-03-02 23:10:10 发布
最新推荐文章于 2022-03-02 23:10:10 发布
阅读量346 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21685903/article/details/107627384
版权

在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

10-安全传输平台项目-第04天（统一通信组件-统一共享内存组件）

 

一、复习

1、wind下制作动态库
2、linux下制作动态库
3、makefile复习
4、统一通信组件—socket通信
5、统一通信组件-服务器端实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
 
#include "poolsocket.h"    
 
 void *start_routine(void * arg)
 {
     int ret;
     int timeout = 3;
     int connfd = (int)arg;
     
     unsigned char *out = NULL;
     int outlen = 0;
     
     while (1) {

        //服务器端端接受报文
        ret = sckServer_rev(connfd, timeout, &out, &outlen); 
        if (ret == Sck_ErrPeerClosed) {
            // 检测到 对端关闭，关闭本端。
            printf("----------------ErrPeerClosed 关闭服务器\n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器检测到客户端发送数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("未知错误\n");
            break;
        }
    
        // 处理数据。 ----- 回射
        printf("====客户端发送了：%s\n", out);
    
         //服务器端发送报文
        ret = sckServer_send(connfd, timeout, out, outlen);
         if (ret == Sck_ErrPeerClosed) {
            // 检测到 对端关闭，关闭本端。
            printf("---ErrPeerClosed \n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器检测到本端发送数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("未知错误\n");
            break;
        }
    }
    sckServer_close(connfd);
     return NULL;
 }

int main(void)
{
    int listenfd;
    int port = 8080;
    int ret = 0;
    
    int timeout = 3;
    int connfd = -1;
    
    pthread_t pid;
    
    //服务器端初始化
    ret = sckServer_init(port, &listenfd);
    if (ret != 0) {
        printf("sckServer_init error %d\n", ret);    
        return ret;
    }
    
    while (1) {
        ret = sckServer_accept(listenfd, timeout, &connfd);
        if (ret == Sck_ErrTimeOut){
            printf("-----客户端连接超时----\n");
            continue;    
        } else if(ret != 0)  {
            printf("sckServer_accept error %d\n", ret);    
            return ret;
        }
        ret = pthread_create(&pid, NULL, start_routine, (void *)connfd);                    
    }
     
     //服务器端环境释放 
    sckServer_destroy();

    return 0;    
}
server.c

 

二、安全传输平台项目—统一通信组件

1、客户端连接服务器

》编写client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
 
#include "poolsocket.h"  

int main(void)
{
    char *ip = "127.0.0.1"; 
    int port = 8080;
    int time = 3; 
    int connfd = -1;
    int ret = -1;
    
    unsigned char *data = "abcdefg";
    int datalen = 5;
    
    unsigned char *out = NULL;
    int outlen = -1;
    
    //客户端 初始化
    ret = sckClient_init();
    if (ret != 0) {
        printf("sckClient_init error %d\n", ret);    
        return ret;
    }
    
    while (1) {
    
        //客户端 连接服务器
        ret = sckClient_connect(ip, port, time, &connfd);
         if (ret == Sck_ErrTimeOut) {
            printf("---客户端连接服务器 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("客户端连接服务器 失败： errorNO：%d\n", ret);
            break;
        }
            
        //客户端 发送报文
        ret = sckClient_send(connfd, time, data, datalen);
        if (ret == Sck_ErrPeerClosed) {
            printf("---服务器关闭，客户端断开连接 \n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器接收数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("客户端发送数据失败：errorNO:%d\n", ret);
            break;
        }
        sleep(1);

        //客户端 接受报文
        ret = sckClient_rev(connfd, time, &out, &outlen); 
        if (ret == Sck_ErrPeerClosed) {
            printf("---服务器关闭，客户端断开连接 \n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器发送数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("客户端接收数据失败：errorNO:%d\n", ret);
            break;
        }    
    }

    //客户端 关闭和服务端的连接
    if (connfd != -1)
        sckClient_closeconn(connfd);
        
    //客户端 释放
    sckClient_destroy();
    
    return 0;    
}
client.c

创建目录test，把makefile、libitcastsocket.so、poolsocket.h放入test目录下。

>make

>./server

打开另一个终端，切换到test目录下，执行>./client，然后查看原终端的数据接收情况。

注意中文乱码，需要转换：

为什么会出现服务器检测到客户端发送数据超时？

 

2、客户端连接池连接服务器

》编写client2.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
 
#include "poolsocket.h" 

/*
typedef struct _SCKClitPoolParam
{
    char     serverip[64];
    int     serverport;
    int     bounds; //池容量
    int     connecttime;
    int     sendtime;
    int     revtime;
}SCKClitPoolParam;
*/ 

void *mystart_routin(void *arg) 
{
    int ret = 0;
    int connfd = -1;
    void *handle = arg;
    
    unsigned char *data = "abcdefg";
    int datalen = 5;
    
    unsigned char *out = NULL;
    int outlen = -1;
        
    // 获取一条连接池中的链接：
    ret = sckCltPool_getConnet(handle, &connfd);
    if (ret != 0) {
        printf("从连接池 获取 连接失败：%d\n", ret);
        return NULL;    
    }
    //可以增加发送数据的次数，flag=10，flag--
    while (1) {
        ret = sckCltPool_send(handle, connfd, data, datalen);
        if (ret == Sck_ErrPeerClosed) {
            printf("---服务器关闭，客户端断开连接 \n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器接收数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("客户端发送数据失败：errorNO:%d\n", ret);
            break;
        }
        
        ret = sckCltPool_rev(handle, connfd, &out, &outlen); 
        if (ret == Sck_ErrPeerClosed) {
            printf("---服务器关闭，客户端断开连接 \n");
            break;
        } else if (ret == Sck_ErrTimeOut) {
            printf("---服务器发送数据 超时 \n");
            continue;
        } else if (ret != 0) {
            printf("客户端接收数据失败：errorNO:%d\n", ret);
            break;
        }
        printf("------接收到 服务器回发数据：%s\n", out);        
    }
    sckCltPool_putConnet(handle, connfd, 0); 

    
    return NULL;
}


int main(void)
{
    int i = 0;
    int ret = 0;
    pthread_t pidArray[6] = {0};
    
    SCKClitPoolParam clientPoolparam;
    strcpy(clientPoolparam.serverip, "127.0.0.1");
    clientPoolparam.serverport = 8080;
    clientPoolparam.bounds = 10;
    clientPoolparam.connecttime = 3;
    clientPoolparam.sendtime = 3;
    clientPoolparam.revtime = 3;
    
    void *handle = NULL;

    //客户端 初始化
    ret = sckCltPool_init(&handle, &clientPoolparam);
    if (ret != 0) {
        printf("sckCltPool_init error %d\n", ret);    
        return ret;
    }
    
    while (1) {
        
        for (i = 0; i < 6; i++) {
            pthread_create(&pidArray[i], NULL, mystart_routin, handle);    //需要判断返回值
        }
        
        for (i = 0; i< 6; i++) {
            pthread_join(pidArray[i], NULL);    
        }
    }

    //销毁连接池
    sckCltPool_destroy(handle);

    return 0;    
}
client2.c

>make

>./server

打开另一个终端，切换到test目录下，执行>./client，然后查看原终端的数据接收情况。

 

3、线程传参现象展示

>vi a_server.c

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include "poolsocket.h"


void *mystart_routine(void *arg)
{
    int         ret = 0;
    int         timeout = 3;
    int         connfd = (int)arg;
    
    unsigned char     *out = NULL;
    int             outlen = 0;
    
    while (1)
    {    
        //服务器端端接受报文
        ret =  sckServer_rev(connfd, timeout, &out, &outlen); //1
        if (ret == Sck_ErrPeerClosed)
        {
            //printf("aaaaa \n");
            printf("服务器端检测到客户端有一条连接已关闭 \n");
            break;
        }
        else if (ret == Sck_ErrTimeOut)
        {
            printf("服务器端send超时\n");
            continue;
        }
        else if (ret != 0)
        {
            printf("服务器端 sckServer_send() err\n");
            break;
        }
    
        printf("out:%s \n", out);  //回射
        
        //服务器端发送报文
        ret =  sckServer_send(connfd, timeout, out, outlen);
        if (ret == Sck_ErrPeerClosed)
        {
            sck_FreeMem((void **)&out);
            printf("服务器端检测到客户端有一条连接已关闭\n");
            break;
        }
        else if (ret == Sck_ErrTimeOut)
        {
            sck_FreeMem((void **)&out);
            printf("服务器端send超时\n");
            continue;
        }
        else if (ret != 0)
        {
            sck_FreeMem((void **)&out);
            printf("服务器端 sckServer_send() err\n");
            break;
        }
        sck_FreeMem((void **)&out);
    }
    
    sckServer_close(connfd);
    return NULL;
}


int main()
{
    int         ret         = 0;
    int             port         = 8001;
    int         listenfd     = 0;
    int         timeout        = 3;
    int         connfd = 0;
    pthread_t     pid;
    
    
    //函数声明
    //服务器端初始化
    ret = sckServer_init(port, &listenfd);
    if (ret != 0)
    {
        printf("func sckServer_init() err:%d \n", ret);
        return ret;
    }
    
    while (1)
    {
        ret = sckServer_accept(listenfd, timeout, &connfd);
        if (ret == Sck_ErrTimeOut)
        {
            printf("func sckServer_accept() Sck_ErrTimeOut\n");
            continue;
        }
        else if (ret != 0)
        {
            ret = 2;
            printf("fun sckServer_accept() err :%d \n", ret);
            break;
        }
    
        pthread_create(&pid, NULL,  mystart_routine, (void *)(connfd));

    }


    //服务器端环境释放 
    int sckServer_destroy();
    printf("hello....\n");    
}
a_server.c

>vi a_client3err.c

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include "poolsocket.h"

typedef struct _ThreadInfo
{
    void     *handle;
    int     iLoop;
    int     iArrayIndex;   //线程数组的下标
}ThreadInfo;


void* myclient_startroutine (void *arg)
{
     int             i = 0, ret = 0;
     int             connfd = 0;
 
    char             data[64] = {0};
     int             datalen = 0;
     
    unsigned char  *out = NULL;
    int             outlen = 0;
    
    ThreadInfo         *pThreadInfo = (ThreadInfo *)arg;
    void             *handle = pThreadInfo->handle; //

    
    //客户端 socket池 获取一条连接 
    ret = sckCltPool_getConnet(handle, &connfd);
    if (ret != 0)
    {
        printf("func sckCltPool_getConnet() err:%d\n", ret);
        return NULL;
    }
    
    for (i=0; i<pThreadInfo->iLoop; i++)
    {
        //客户端 socket池 发送数据 
        memset(data, 0, sizeof(data));
        sprintf(data, "第%d线程, 第%d圈", pThreadInfo->iArrayIndex, i+1);
        
        ret = sckCltPool_send(handle, connfd,  data, strlen(data));
        if (ret == Sck_ErrPeerClosed)
         { 
             printf("sckCltPool_send 客户端检测到 服务器已经关闭 退出\n");
             break;    
         }
         else if (ret == Sck_ErrTimeOut)
         {
             printf(" sckCltPool_send timeout \n");
             break;
         }
         else if (ret != 0)
         {
             printf("fun sckServer_rev() err:%d \n", ret);
             break;
         }

        //客户端 socket池 接受数据
        ret =  sckCltPool_rev(handle, connfd, &out, &outlen); //1
        if (ret == Sck_ErrPeerClosed)
         { 
             printf("sckCltPool_rev 客户端检测到 服务器已经关闭 退出\n");
             break;    
         }
         else if (ret == Sck_ErrTimeOut)
         {
             printf(" sckCltPool_rev timeout \n");
             break;
         }
         else if (ret != 0)
         {
             printf("fun sckCltPool_rev() err:%d \n", ret);
             break;
         }
         printf("客户端 out:%s \n", out);
         sck_FreeMem((void **)&out);
    }
    
    //客户端 socket池 把连接放回 socket池中 
    sckCltPool_putConnet(handle, connfd, 0); //0正常 1
    
     return NULL;
}
 
int main(void)
{
    int         ret = 0, i = 0;
    char         *ip = "127.0.0.1"; 
    int         port = 8001;
    int         time = 3;
    int         connfd = 0;
    
    int            iLoop = 0; //圈数
    int            iThreadNum = 0 ; //线程数
    
    void         *handle = NULL;
    pthread_t     pidArray[1024]; 
    
    ThreadInfo             threadInfo;
    memset(&threadInfo, 0, sizeof(ThreadInfo));
    
    SCKClitPoolParam            sckClitPoolParm;
    memset(&sckClitPoolParm, 0, sizeof(SCKClitPoolParam));
    strcpy(sckClitPoolParm.serverip,  "127.0.0.1");
    sckClitPoolParm.serverport = 8001;
    sckClitPoolParm.bounds = 10;
    sckClitPoolParm.connecttime = 3;
    sckClitPoolParm.sendtime = 3;
    sckClitPoolParm.revtime = 3;
    
    
    printf("\n请输入线程的个数: ");
    scanf("%d", &iThreadNum);
    
    printf("\n请输入每个线程运行圈数: ");
    scanf("%d", &iLoop);
    
    if (iThreadNum >= 1024)
    {
        printf("iThreadNum大于1024\n");
        return 0;
    }

    //客户端 socket池初始化
    ret = sckCltPool_init(&handle,  &sckClitPoolParm);
    if (ret != 0)
    {
        printf("func  sckCltPool_init() err:%d \n ", ret);
        return ret;
    }
    
    //启动多线程 
    for (i=0; i<iThreadNum; i++)
    {
        threadInfo.handle = handle;              //alt + 鼠标键左键拖动 
        threadInfo.iLoop =  iLoop;
        threadInfo.iArrayIndex = i + 1;
    pthread_create(&pidArray[i], NULL, myclient_startroutine, (void *)&threadInfo);
    }
    
    
    //主进程 等待子线程 结束
    for (i=0; i<iThreadNum; i++)
    {
         pthread_join(pidArray[i], NULL);
    }
    
    
    //客户端 socket池 销毁连接
    sckCltPool_destroy(handle);

    printf("client hello....\n");
    
    
    return 0;
}
a_client3err.c

>make

>./a_server

打开另一个终端，切换到test目录下，执行>./a_client3err，然后查看原终端的数据接收情况。

1）问题：pthread_create(&pidArray[i], NULL, myclient_startroutine, (void *)&threadInfo);中的最后一个参数需要加地址符号吗？

由于threadInfo是一个结构体，从大小及值拷贝需要的空间复杂度考虑，所以必须传入地址，不能传值。结论——结构体做参数，最好传地址！！！

2）问题：每次都是最后一个线程跑圈？

分析：pthread_create传参最后一个参数threadInfo使用了地址传参。需要看4、线程传参内存冗余法

 

4、线程传参内存冗余法

》内存冗余分析图：

注意：形参和局部变量地位等同，都位于栈上。

原因：线程子函数栈空间调用了main函数栈空间的值，当线程几乎同时创建时，去读取main栈空间的值时，main栈空间的值i还在变化（自增）。所以需要为每个线程子函数创建属于自己的栈空间。

>vi a_client4.c

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include "poolsocket.h"

typedef struct _ThreadInfo
{
    void     *handle;
    int     iLoop;
    int     iArrayIndex;//线程数组的下标
}ThreadInfo;


 void* myclient_startroutine (void *arg)
 {
     int             i = 0, ret = 0;
     int             connfd = 0;
 
     char             data[64] = {0};
      int             datalen = 0;
     
    unsigned char  *out = NULL;
    int             outlen = 0;
    
    ThreadInfo         *pThreadInfo = (ThreadInfo *)arg;
    void             *handle = pThreadInfo->handle; //

    
    //客户端 socket池 获取一条连接 
    ret = sckCltPool_getConnet(handle, &connfd);
    if (ret != 0)
    {
        printf("func sckCltPool_getConnet() err:%d\n", ret);
        return NULL;
    }
    
    for (i=0; i<pThreadInfo->iLoop; i++)
    {
        //客户端 socket池 发送数据 
        memset(data, 0, sizeof(data));
        sprintf(data, "第%d线程, 第%d圈", pThreadInfo->iArrayIndex, i+1);
        ret = sckCltPool_send(handle, connfd,  data, strlen(data));
        if (ret == Sck_ErrPeerClosed)
         { 
             printf("sckCltPool_send 客户端检测到 服务器已经关闭 退出\n");
             break;    
         }
         else if (ret == Sck_ErrTimeOut)
         {
             printf(" sckCltPool_send timeout \n");
             break;
         }
         else if (ret != 0)
         {
             printf("fun sckServer_rev() err:%d \n", ret);
             break;
         }

        //客户端 socket池 接受数据
        ret =  sckCltPool_rev(handle, connfd, &out, &outlen); //1
        if (ret == Sck_ErrPeerClosed)
         { 
             printf("sckCltPool_rev 客户端检测到 服务器已经关闭 退出\n");
             break;    
         }
         else if (ret == Sck_ErrTimeOut)
         {
             printf(" sckCltPool_rev timeout \n");
             break;
         }
         else if (ret != 0)
         {
             printf("fun sckCltPool_rev() err:%d \n", ret);
             break;
         }
         printf("客户端 out:%s \n", out);
         sck_FreeMem((void **)&out);
    }
    
    //客户端 socket池 把连接放回 socket池中 
    sckCltPool_putConnet(handle, connfd, 0); //0正常 1
    
    if (arg != NULL) free(arg);
    
     return NULL;
 }
 
int  main()
{
    int         ret = 0, i = 0;
    char         *ip = "127.0.0.1"; 
    int         port = 8001;
    int         time = 3;
    int         connfd = 0;
    
    int            iLoop = 0; //圈数
    int            iThreadNum = 0 ; //线程数
    
    void         *handle = NULL;
    pthread_t         pidArray[1024]; 
    
    //ThreadInfo             threadInfo;
    //memset(&threadInfo, 0, sizeof(ThreadInfo));
    
    SCKClitPoolParam            sckClitPoolParm;
    memset(&sckClitPoolParm, 0, sizeof(SCKClitPoolParam));
    strcpy(sckClitPoolParm.serverip,  "127.0.0.1");
    sckClitPoolParm.serverport = 8001;
    sckClitPoolParm.bounds = 20;  //node: 客户端线程池的个数是10个
    sckClitPoolParm.connecttime = 3;
    sckClitPoolParm.sendtime = 3;
    sckClitPoolParm.revtime = 3;
    
    
    printf("\n请输入线程的个数: ");
    scanf("%d", &iThreadNum);
    
    printf("\n请输入每个线程运行圈数: ");
    scanf("%d", &iLoop);
    
    if (iThreadNum >= 1024)
    {
        printf("iThreadNum大于1024\n");
        return 0;
    }

    //客户端 socket池初始化
    ret = sckCltPool_init(&handle,  &sckClitPoolParm);
    if (ret != 0)
    {
        printf("func  sckCltPool_init() err:%d \n ", ret);
        return ret;
    }
    
    //启动多线程 
    for (i=0; i<iThreadNum; i++)
    {
        ThreadInfo *pInfo = (ThreadInfo *)malloc(sizeof(ThreadInfo));
        pInfo->handle = handle;              //alt + 鼠标键左键拖动 
        pInfo->iLoop =  iLoop;
        pInfo->iArrayIndex = i + 1;
        pthread_create(&pidArray[i], NULL, myclient_startroutine, (void *)pInfo);
    }
    
    
    //主进程 等待子线程 结束
    for (i=0; i<iThreadNum; i++)
    {
         pthread_join(pidArray[i], NULL);
    }
    
    
    //客户端 socket池 销毁连接
    sckCltPool_destroy(handle);

    printf("client hello....\n");
    return 0;
}
a_client4.c

>make

>./a_server

打开另一个终端，切换到test目录下，执行>./a_client4，然后查看原终端的数据接收情况。

 

三、安全传输平台项目—统一共享内存组件

1、常见IPC

 

2、简单内存模型分析

 

3、共享内存操作函数—shmget

 

4、共享内存操作函数—shmat_dt

 

5、共享内存操作函数—shmctl

 

6、Linux内核管理共享内存方法

 

7、共享内存操作函数接口

 

 

四、客户端服务器密钥协商预说明

 

在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

AllisWell_WP
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
安全传输平台项目.txt
03-20
安全传输平台项目
安全传输平台项目——密钥协商服务器-密钥协商客户端
Alliswell_WP
07-28 720
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目-第05天（密钥协商服务器-密钥协商客户端） 目录：一、复习二、安全传输平台项目——密钥协商服务器-密钥协商客户端1、密钥协商-物理组件集成2、密钥协商-日志的使用3、密钥协商客户端-模块划分4、密钥协商客户端-框架实现5、密钥协商客户端-Agree函数框...
数据安全传输平台项目笔记
DanielSYC的博客
03-02 9867
C++实现的基于Linux的数据安全传输平台
安全传输平台项目——简介-需求-方案-演示-部署
Alliswell_WP
07-22 474
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目-第01天（简介-需求-方案-演示-部署） 一、安全传输平台项目 1、项目综述 2、对称加密和非对称加密 3、项目需求分析 4、项目开发流程注意事项 5、项目模块分工 6、数据库配置、防火墙关闭 7、数据库启动 8、数据库TN...
安全传输平台项目——配置管理终端-读写数据库
Alliswell_WP
08-01 182
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目-第10天（配置管理终端-读写数据库） 一、复习 二、安全传输平台项目——配置管理终端-读写数据库 1、连接数据库 2、管理终端操作数据库原理 3、服务器配置参数管理界面布局 4、记录类的概念 5、生成记录类 6、记录类常用AP...
网络安全概述(ppt-105页).pptx
最新发布
06-09
防火墙本身不会影响信息的流通 防火墙是位于两个信任程度不同的网络之间（如企业内部网络和Internet之间）的软件或硬件设备的组合，它对两个网络之间的通信进行控制，通过强制实施统一的安全策略，防止对重要信息...
论文研究-基于agent技术的EMIF数据共享与互操作的设计与实现.pdf
07-22
介绍了EMIF框架模型，对实现EMIF数据共享的关键组件——通信agent的需求模型、功能模型和实现方法进行了系统分析和讨论，对该agent关键功能——报文处理及传输、代理接口等进行了详尽的设计。
JAVA上百实例源码以及开源项目
01-03
　Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程技能的提升很有帮助。 Java聊天程序，包括服务端和...
JAVA上百实例源码以及开源项目源代码
09-17
　Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程技能的提升很有帮助。 Java聊天程序，包括服务端和...
成百上千个Java 源码DEMO 4(1-4是独立压缩包)
03-29
28个目标文件 内容索引:JAVA源码,媒体网络,飞鸽传书 Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程...
安全文件传输
09-28
国嵌安全文件传输系统项目试验手册，有代码
通过COM组件共享内存的进程间通信Demo
01-16
通过COM组件封存共享内存的方法，并添加到注册表，成为一个共享内存的服务。任何一个进程只要使用这个服务，就可以访问到共享内存。方便不同进程间通信，增加了通信效率。但是慎用这种方法，该方法已经在WINDOWS7下通过测试，XP下有时候会弹错。
统一权限组件
06-01
NULL 博文链接：https://13813962825.iteye.com/blog/2113369
P2P文件的安全传输系统
10-11
基于Windows操作系统和winpcap软件包，结合对称与非对称加密算法和散列算法、数字签名原理，设计基于p2p文件传输的安全通信处理流程，定义数据包格式，通过c++开发一个p2p文件的安全通信软件。 实现： Windows环境下的安全文件传输服务：1.文件加/解密 2.数据源认证 3.数据完整性 等
国嵌高级项目3(安全文件传输系统)源代码
11-02
国嵌高级项目3(安全文件传输系统)源代码
安全传输平台项目扩展——项目延展
Alliswell_WP
08-05 429
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目扩展-第03天（项目延展-项目演说） 目录：一、复习二、安全传输平台项目扩展——项目延展 一、复习 》4大基础组件： 1）统一报文编码解码 libmessagereal.so .h ---> .dll .lib .h 2）统一...
安全数据传输平台项目——总结2.0 --- vs2013 linux 动态库。
weixin_30753873的博客
07-19 168
1.动态库的创建 　　在Linux平台下利用gcc命令: gcc -fPIC -shared -o lib<动态库名>.so <相关.c 和 .o文件> 　　在Windows下使用VS:(我用的是2013) 　　 　　选择Visual C++下的Win32控制台应用程序,然后按下确定,你会进入如下画面: 　　 　　下一步------ 　　 　　按...
安全传输平台项目——密钥协商共享内存-守护进程-脚本
Alliswell_WP
07-29 412
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目-第06天（密钥协商共享内存-守护进程-脚本） 目录：一、复习二、密钥协商共享内存-守护进程-脚本1、共享内存操作函数接口设计2、共享内存操作函数实现领读3、生成密钥-组织密钥结构体信息4、客户端写密钥信息到共享内存5、服务器内存释放6、共享内存补充说明7...
安全传输平台项目——配置管理终端-框架搭建-初始化
Alliswell_WP
07-31 565
在学习安全传输平台项目总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 10-安全传输平台项目-第09天（配置管理终端-框架搭建-初始化） 一、复习 1、复习数据库写入2、复习框架导入 》创建MFC项目： 主函数（类似于main）在SecMngAdmin0325.cpp中。 界面部分在MainFrm.cpp中，需要在其中添加启动的样式： 1）...
开源的大数据调度平台，可以统一管理大数据相关组件
04-05
的调度任务、数据传输、数据处理等，...这些平台都提供了丰富的组件支持，可以轻松地实现数据的传输、转换、处理等操作。同时，它们还提供了可视化的操作界面和灵活的任务调度配置，方便用户进行大数据任务管理和调度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值