萌面大叔2
萌面大叔2

查看上传下载

chatClient.c

#include "chatClient.h"

Head *g_pHead = NULL;
void sendDataToServer(int sockfd, ChatPDU *pChatPDU)
{
    if (NULL == pChatPDU)
    {
        return;
    }
    int ret = 0;
    int iLeft = pChatPDU->iChatPDULen;
    int iSend = 0;
    ret = write(sockfd, pChatPDU, iLeft);
    if (-1 == ret)
    {
        PRINT_ERROR("send");
        return;
    }
    iLeft -= ret;  //还有多少数据要发送
    iSend += ret;  //已发送的数据大小
    while (ret > 0 && iLeft)
    {
        ret = write(sockfd, (char *)pChatPDU+iSend
                    , iLeft);
        if (-1 == ret)
        {
            PRINT_ERROR("send");
            return;
        }
        iLeft -= ret;
        iSend += ret;
    }
}

ChatPDU *readDataFromServer(int sockfd)
{
    int ret = 0;
    unsigned int iPDULen = 0;
    ret = read(sockfd, &iPDULen, sizeof(int));
    if (-1 == ret)
    {
        PRINT_ERROR("recv");
        return;
    }
    ChatPDU *pChatPDU = makeChatPDU(iPDULen);
    memset(pChatPDU, 0, iPDULen);
    pChatPDU->iChatPDULen = iPDULen;
    int iLeft = iPDULen - ret;  //剩余的数据大小
    int iRecv = ret;   //已读的数据大小
    while (ret > 0 && iLeft)
    {
        ret = read(sockfd, (char*)pChatPDU+iRecv
                   , iLeft);
        if (-1 == ret)
        {
            PRINT_ERROR("recv");
            return;
        }
        iRecv += ret;
        iLeft -= ret;
    }
    return pChatPDU;
}

int makeSocket()
{
    int sockfd = 0;
    //AF_INET: ipv4
    //SOCK_STREAM: tcp/ip
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd)
    {
        PRINT_ERROR("socket");
        exit(-1);
    }
    return sockfd;
}
int connectToServer(int sockfd)
{
    struct sockaddr_in servaddr;
    //地址协议:ipv4
    servaddr.sin_family = AF_INET;
    //服务器端口
    servaddr.sin_port = htons(8668);
    //服务器ip
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    bzero(&(servaddr.sin_zero), 8);
    int ret = connect(sockfd
                      , (struct sockaddr *)&servaddr
                      , sizeof(struct sockaddr));
    if (-1 == ret)
    {
        PRINT_ERROR("connect");
        exit(-1);
    }
    return ret;
}

int operateUI()
{
    printf("1,查看文件\t2,上传文件\n");
    printf("3,下载文件\t4,文件重命名\n");
    printf("ope:");
    int iOpe = 0;
    scanf("%d", &iOpe);
    if (CHAECK_INPUT(iOpe, 1, 4))
    {
        return iOpe;
    }
    return -1;
}

static void getFileListFromPDU(const ChatPDU *pChatPDU)
{
    if (NULL != pChatPDU)
    {
        int iNum = 0;
        Node *pNode = NULL;
        iNum = pChatPDU->iChatDataLen/FILE_NAME_LEN;
        int i = 0;
        for (; i < iNum; i++)
        {
            pNode = makeNode();
            memcpy(pNode->caName
                   , pChatPDU->chatData+i*FILE_NAME_LEN
                   , FILE_NAME_LEN);
            insertList(g_pHead, pNode);
        }
    }
}

static void handleAskFileList(int sockfd)
{
    destoryList(g_pHead);

    int iLen = sizeof(ChatPDU);
    ChatPDU *pChatPDU = makeChatPDU(iLen);
    if (NULL != pChatPDU)
    {
        pChatPDU->iChatPDULen = iLen;
        pChatPDU->iType = ENUM_TYPE_ASK_FILE_INFO;
        sendDataToServer(sockfd, pChatPDU);
        freePDU(pChatPDU);
        pChatPDU = NULL;

        pChatPDU = readDataFromServer(sockfd);
        getFileListFromPDU(pChatPDU);
        freePDU(pChatPDU);
        pChatPDU = NULL;

        showList(g_pHead);
    }
}

void readDataFromSTDIN(char caData[FILE_IO_MAX_LEN])
{
    memset(caData, '\0', FILE_IO_MAX_LEN);
    int ret = read(STDIN_FILENO, caData, FILE_IO_MAX_LEN);
    if (-1 == ret)
    {
        perror("read");
        return;
    }
    if ('\0' != caData[FILE_IO_MAX_LEN-1]
            && '\n' != caData[FILE_IO_MAX_LEN-1])
    {
        while ('\n' != getchar())
        {}
    }
    caData[FILE_IO_MAX_LEN-1] = '\0';
}

static void handleUploadFile(int sockfd)
{
    char caData[FILE_IO_MAX_LEN];
    // 输入时以'/'结束
    printf("请输入要上传的文件路径(以\'/\'结尾):\n");
    readDataFromSTDIN(caData);
    char caPath[64];
    memset(caPath, '\0', 64);
    sscanf(caData, "%s", caPath);
    scanFileInfo(caPath);

    printf("请输入要上传的文件名:\n");
    readDataFromSTDIN(caData);
    char caName[32] = {'\0'};
    memset(caName, '\0', 32);
    sscanf(caData, "%s", caName);

    Node *pNode = makeNode();
    initNode(pNode, caName);
    insertList(g_pHead, pNode);

    strcat(caPath, caName);
    printf("name=%s\n", caPath);

    int fd = openFile(caPath);
    int ret = -1;
    int iLen = sizeof(ChatPDU)-sizeof(int)+FILE_IO_MAX_LEN;
    ChatPDU *pChatPDU = makeChatPDU(iLen);
    pChatPDU->iChatPDULen = iLen;
    pChatPDU->iType = ENUM_TYPE_UPLOAD_FILE;
    strcpy(pChatPDU->caFileName, caName);
    while (ret = read(fd, caData, FILE_IO_MAX_LEN))
    {
        pChatPDU->iChatDataLen = ret;
        memcpy(pChatPDU->chatData, caData, ret);
        sendDataToServer(sockfd, pChatPDU);
    }
    freePDU(pChatPDU);
}

void handleDownloadFile(int sockfd)
{
    int iLen = sizeof(ChatPDU);
    ChatPDU *pChatPDU = makeChatPDU(iLen);
    if (NULL != pChatPDU)
    {
        char caData[FILE_IO_MAX_LEN];
        char caPath[64];

        pChatPDU->iChatPDULen = iLen;
        pChatPDU->iType = ENUM_TYPE_ASK_DOWNLOAD_FILE;

        showList(g_pHead);
        printf("请输入要下载的文件名:\n");
        readDataFromSTDIN(caData);
        sscanf(caData, "%s", caPath);
        strcpy(pChatPDU->caFileName, caPath);

        sendDataToServer(sockfd, pChatPDU);
        freePDU(pChatPDU);
        pChatPDU = NULL;

        unsigned int iReceivedFileSize = 0;
        // 输入时以'/'结束
        printf("请输入要保存的文件路径(以\'/\'结尾):\n");
        readDataFromSTDIN(caData);
        memset(caPath, '\0', 64);
        sscanf(caData, "%s", caPath);
        pChatPDU = readDataFromServer(sockfd);
        strcat(caPath, pChatPDU->caFileName);
        int fd = -1;
        fd = openFile(caPath);
        lseek(fd, 0, SEEK_END);
        printf("file size = %d\n", pChatPDU->iFileSize);
        while (1)
        {
            memset(caData, '\0', FILE_IO_MAX_LEN+1);
            strncpy(caData, pChatPDU->chatData, pChatPDU->iChatDataLen);
            printf("per size = %d\n", pChatPDU->iChatDataLen);

            lseek(fd, 0, SEEK_END);
            writeDataToFile(fd, caData, pChatPDU->iChatDataLen);

            iReceivedFileSize += pChatPDU->iChatDataLen;
            printf("rec=%d\n", iReceivedFileSize);
            printf("total = %d\n", pChatPDU->iFileSize);
            if (iReceivedFileSize == pChatPDU->iFileSize)
            {
                freePDU(pChatPDU);
                pChatPDU = NULL;
                break;
            }

            freePDU(pChatPDU);
            pChatPDU = NULL;

            pChatPDU = readDataFromServer(sockfd);
        }
        closeFile(fd);
        printf("文件下载完成\n");
    }
}

void interactWithServer(int sockfd)
{
    g_pHead = makeList();
    int ret = 0;
    while (1)
    {
        ret = operateUI();
        if (-1 == ret)
        {
            printf("input error\n");
            continue;
        }
        switch (ret)
        {
        case ENUM_FILE_LIST:
            handleAskFileList(sockfd);
            break;
        case ENUM_FILE_UPLOAD:
            handleUploadFile(sockfd);
            break;
        case ENUM_FILE_DOWNLOAD:
            handleDownloadFile(sockfd);
            break;
        case ENUM_FILE_RENAME:
            break;
        default:
            break;
        }
    }
}

chatClient.h

#ifndef CHAT_CLIENT_H
#define CHAT_CLIENT_H

#include 
#include 
/*socket() connect()  recv()*/
#include  
#include 
#include   //struct sockaddr_in
#include   //thread
#include   //malloc()
#include   //read()
#if 1
#include "node.h"
#include "protocol.h"
#include "file.h"
#include "error.h"
#endif
#if 0
#include "../link/node.h"
#include "../protocol/protocol.h"
#include "../file/file.h"
#include "../error/error.h"
#endif
enum FILE_OPE
{
    ENUM_FILE_OPE_MIN = 0,
    ENUM_FILE_LIST,        //查看文件
    ENUM_FILE_UPLOAD,      //上传文件
    ENUM_FILE_DOWNLOAD,    //下载文件
    ENUM_FILE_RENAME,      //文件重命名
    ENUM_FILE_OPE_MAX = 0x0fffffff
};
#define CHAECK_INPUT(i, a, b) ((i)>=(a)&&(i<=(b)))?1:0

void sendDataToServer(int sockfd, ChatPDU *pChatPDU);
ChatPDU *readDataFromServer(int sockfd);
int makeSocket();
int connectToServer(int sockfd);
int operateUI();
void interactWithServer(int sockfd);

#endif

main(client)

#include "chatClient.h"

int main(void)
{
    int sockfd = 0;
    sockfd = makeSocket();
    connectToServer(sockfd);
    interactWithServer(sockfd);

    return 0;
}

error.c

#include "error.h"

error.h

#ifndef ERROR_H
#define ERROR_H

#include 
#include 
#include 

#define PRINT_ERROR(s) printf("%s: errno=%d,err=%s\n", s, errno, strerror(errno));

#endif

file.h

#ifndef FILE_H
#define FILE_H

#include 
#include  //perror strerror 
#include   //errno
/*open()*/
#include 
#include 
#include 
#include  //exit()
#include   //read() write()
#include "node.h"
#include "error.h"

#define FILE_IO_MAX_LEN 4096

int openFile(const char *pFileName);
void readDataFromFile(int fd, char *pBuf);
void writeDataToFile(int fd, const char *pBuf, unsigned int iLen);
void closeFile(int fd);
void scanFileIntoList(Head *pHead, const char *pDirName);
void scanFileInfo(const char *pDirName);

#endif

file.c

#include "file.h"
#include 
#include 

int openFile(const char *pFileName)
{
    int fd = -1;
    if (NULL != pFileName)
    {
        fd = open(pFileName, O_RDWR | O_CREAT
                  , S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
        if (-1 == fd)
        {
            PRINT_ERROR("open file");
            exit(-1);
        }   
    }
    return fd;
}
void readDataFromFile(int fd, char *pBuf)
{
    if (NULL != pBuf && fd >= 0)
    {
        int ret = 0;
        int iLeft = FILE_IO_MAX_LEN;
        int iReaded = 0;
        ret = read(fd, pBuf, iLeft);
        if (-1 == ret)
        {
            PRINT_ERROR("read");
            exit(-1);
        }
        iLeft -= ret;
        iReaded += ret;
        while (ret > 0 && iLeft)
        {
            ret = read(fd, pBuf+iReaded, iLeft);
            if (-1 == ret)
            {
                PRINT_ERROR("read");
                exit(-1);
            }
            iLeft -= ret;
            iReaded += ret;
        }
    }
}
void writeDataToFile(int fd, const char *pBuf, unsigned int iLen)
{
    if (NULL != pBuf && fd >= 0)
    {
        int ret = 0;
        int iLeft = iLen;
        int iWrited = 0;
        ret = write(fd, pBuf, iLeft);
        if (-1 == ret)
        {
            PRINT_ERROR("write");
            exit(-1);
        }
        iLeft -= ret;
        iWrited += ret;
        while (ret > 0 && iLeft)
        {
            ret = write(fd, pBuf+iWrited, iLeft);
            if (-1 == ret)
            {
                PRINT_ERROR("write");
                exit(-1);
            }
            iLeft -= ret;
            iWrited += ret;
        }
    }
}
void closeFile(int fd)
{
    if (fd >= 0)
    {
        int ret = 0;
        ret = close(fd);
        if (-1 == ret)
        {
            PRINT_ERROR("close");
            exit(-1);
        }
    }
}
void scanFileIntoList(Head *pHead
                      , const char *pDirName)
{
    if (NULL == pHead)
    {
        return;
    }

    DIR *pDir = NULL;
    pDir = opendir(pDirName);  //打开目录
    if (NULL == pDir)
    {
        PRINT_ERROR("opendir");
        exit(-1);
    }
    struct dirent *pDirent = NULL;
    Node *pNode = NULL;
    //循环遍历该目录下的文件，返回某个文件的信息
    while (pDirent = readdir(pDir))  
    {
        if (0 == strcmp(".", pDirent->d_name)
            || 0 == strcmp("..", pDirent->d_name))
        {
            continue;
        }
        pNode = makeNode();

        //获得某个文件的名字并保存到节点中
        strncpy(pNode->caName, pDirent->d_name
                , FILE_NAME_LEN);
        insertList(pHead, pNode);
    }
}


void scanFileInfo(const char *pDirName)
{
    DIR *pDir = NULL;
    pDir = opendir(pDirName);  //打开目录
    if (NULL == pDir)
    {
        PRINT_ERROR("opendir");
        exit(-1);
    }
    struct dirent *pDirent = NULL;
    int i = 0;
    //循环遍历该目录下的文件，返回某个文件的信息
    while (pDirent = readdir(pDir))
    {
        if (0 == strcmp(".", pDirent->d_name)
            || 0 == strcmp("..", pDirent->d_name))
        {
            continue;
        }
        printf("%s ", pDirent->d_name);
        i++;
        if (0 == i%5)
        {
            printf("\n");
        }
    }
    printf("\n");
}

node.h

#ifndef NODE_H
#define NODE_H

#include 

#define FILE_NAME_LEN 32
typedef struct Node
{
    char caName[FILE_NAME_LEN];
    struct Node *pNext;
}Node;

typedef struct Head
{
    int iNum;
    Node *pFirstNode;
}Head;

Head *makeList();
Node *makeNode();
void initNode(Node *node, char *pFileName);
void insertList(Head *head, Node *node);
Node *findNode(Head *head, char *pFileName);
void deleteNode(Head *head, char *pFileName);
void showList(Head *head);
void destoryList(Head *head);
void showNode(Node *node);

#endif

node.c

#include "node.h"
#include "error.h"
#include 
#include 

Head *makeList()
{
    Head *pHead = NULL;
    pHead = (Head *)malloc(sizeof(Head));
    if (NULL == pHead)
    {
        PRINT_ERROR("malloc head");
        exit(-1);
    }
    pHead->iNum = 0;
    pHead->pFirstNode = NULL;
    return pHead;   
}
Node *makeNode()
{
    Node *pNode = NULL;
    pNode = (Node *)malloc(sizeof(Node));
    if (NULL == pNode)
    {
        PRINT_ERROR("malloc node");
        exit(-1);
    }
    memset(pNode->caName, '\0', FILE_NAME_LEN);
    pNode->pNext = NULL;
    return pNode;
}
void initNode(Node *node, char *pFileName)
{
    if (NULL != node && NULL != pFileName)
    {
        strcpy(node->caName, pFileName);
    }
}
void insertList(Head *head, Node *node)
{
    if (NULL == head || NULL == node)
    {
        return;
    }
    if (NULL == head->pFirstNode)
    {
        head->pFirstNode = node;
    }
    else
    {
        node->pNext = head->pFirstNode;
        head->pFirstNode = node;
    }
    head->iNum++;
}
Node *findNode(Head *head, char *pFileName)
{
    Node *pNode = NULL;
    if (NULL != head && NULL != pFileName)
    {
        pNode = head->pFirstNode;
        while (NULL != pNode)
        {
            if (0 == strcmp(pNode->caName, pFileName))
            {
                return pNode;
            }
            pNode = pNode->pNext;
        }
    }
    return pNode;
}
void deleteNode(Head *head, char *pFileName)
{
    if (NULL != head && NULL != pFileName)
    {
        Node *pPreNode = head->pFirstNode;
        Node *pCurNode = pPreNode;
        while (NULL != pCurNode)
        {
            if (0 == strcmp(pCurNode->caName
                            , pFileName))
            {
                if (pCurNode == pPreNode)
                {
                    head->pFirstNode = pCurNode->pNext;
                }
                else
                {
                    pPreNode->pNext = pCurNode->pNext;
                }
                break;
            }
            pPreNode = pCurNode;
            pCurNode = pCurNode->pNext;
        }
        if (NULL != pCurNode)
        {
            free(pCurNode);
            pCurNode = NULL;
            head->iNum--;
        }
    }
}
void showList(Head *head)
{
    if (NULL != head)
    {
        Node *pNode = head->pFirstNode;
        while (NULL != pNode)
        {
            printf("name:%s\n", pNode->caName);
            pNode = pNode->pNext;
        }
    }
}
void destoryList(Head *head)
{
    if (NULL != head)
    {
        Node *pNode = head->pFirstNode;
        while (NULL != pNode)
        {
            head->pFirstNode = pNode->pNext;
            free(pNode);
            head->iNum--;
            pNode = head->pFirstNode;
        }
    }
}

void showNode(Node *node)
{
    if (NULL != node)
    {
        printf("name:%s\n", node->caName);
    }
}

protocol.h

#ifndef PROTOCOL_H
#define PROTOCOL_H

#include 

enum TYPE
{
    ENUM_TYPE_MIN = 0,
    ENUM_TYPE_ASK_FILE_INFO, //客户端请求文件信息
    ENUM_TYPE_RESP_FILE_INFO, //服务器返回文件信息

    ENUM_TYPE_UPLOAD_FILE, //客户端上传文件

    ENUM_TYPE_ASK_DOWNLOAD_FILE, //客户端请求下载文件
    ENUM_TYPE_RESP_DOWNLOAD_FILE, //服务器发送文件

    ENUM_TYPE_RENAME_FILE, //客户端重命名文件
    ENUM_TYPE_DELETE_FILE, //客户端删除文件

    ENUM_TYPE_MAX = 0x0fffffff
};

#define SERVER 0

typedef struct ChatPDU
{
    unsigned int iChatPDULen;   //数据单元总大小
    unsigned int iType;         //消息类型
    unsigned int iChatDataLen;  //消息大小
    char caFileName[32];        //文件名字
    unsigned int iFileSize;     //文件大小
    char chatData[4];           //发送的消息
}ChatPDU;

ChatPDU *makeChatPDU(int len);
int parsePDU(ChatPDU *pChatPDU);
void freePDU(ChatPDU *pChatPDU);

#endif

protocol.c

#if 1
#include "protocol.h"
#include "error.h"
#endif
#include 
#include 

ChatPDU *makeChatPDU(int len)
{
    if (len <= 0)
    {
        return NULL;
    }
    ChatPDU *pChatPDU = (ChatPDU *)malloc(len);
    if (NULL == pChatPDU)
    {
        PRINT_ERROR("malloc PDU");
        exit(-1);
    }
    memset(pChatPDU, 0, len);
    return pChatPDU;
}
int parsePDU(ChatPDU *pChatPDU)
{
    if (NULL == pChatPDU)
    {
        return ENUM_TYPE_MIN;
    }
    return pChatPDU->iType;
}
void freePDU(ChatPDU *pChatPDU)
{
    if (NULL != pChatPDU)
    {
        free(pChatPDU);
        pChatPDU = NULL;
    }
}

chatServer.h

#ifndef CHAT_SERVER_H
#define CHAT_SERVER_H

#include 
#include 
#include 
/*socket()  send()*/
#include 
#include 

#include 
#include   //fork()

/*wait()*/
#include 
#include 
#include   //signal()

#include   //thread
#include "node.h"
#include "protocol.h"
#include "error.h"
#include "file.h"

#include   //exit()

int makeSocket();
void bindSocketAddr(int sockfd);
void listenClient(int sockfd);
void handle(int sockfd);

#endif

chatServer.c

#include "chatServer.h"

Head *g_pHead = NULL;
#define FILE_PATH "file/"

static void sendDataToClient(int sockfd
                             , const ChatPDU *pChatPDU)
{
    if (NULL == pChatPDU)
    {
        return;
    }
    int ret = 0;
    int iLeft = pChatPDU->iChatPDULen;
    int iSend = 0;
    ret = write(sockfd, pChatPDU, iLeft);
    iLeft -= ret;  //还有多少数据要发送
    iSend += ret;  //已发送的数据大小
    while (ret > 0 && iLeft)
    {
        ret = write(sockfd, (char *)pChatPDU+iSend, iLeft);
        iLeft -= ret;
        iSend += ret;
    }
}

static ChatPDU *readDataFromClient(int sockfd)
{
    int ret = 0;
    unsigned int iPDULen = 0;
    ret = read(sockfd, &iPDULen, sizeof(int));
    if (-1 == ret)
    {
        PRINT_ERROR("recv");
        return NULL;
    }
    printf("pdulen:%d\n", iPDULen);
    ChatPDU *pChatPDU = makeChatPDU(iPDULen);
    pChatPDU->iChatPDULen = iPDULen;

    int iLeft = iPDULen - ret;  //剩余的数据大小
    int iRecv = ret;   //已读的数据大小
    while (ret > 0 && iLeft)
    {
        ret = read(sockfd, (char*)pChatPDU+iRecv, iLeft);
        iRecv += ret;
        iLeft -= ret;
    }
    printf("datalen:%d\n", pChatPDU->iChatDataLen);
    return pChatPDU;
}

void sendFileListToClient(int sockfd)
{
    if (NULL == g_pHead)
    {
        return;
    }

    destoryList(g_pHead);
    scanFileIntoList(g_pHead, FILE_PATH);

    unsigned int iLen = sizeof(ChatPDU) + (g_pHead->iNum) * FILE_NAME_LEN - sizeof(int);
    ChatPDU *pChatPDU = NULL;
    pChatPDU = makeChatPDU(iLen);
    Node *pNode = g_pHead->pFirstNode;
    unsigned int i = 0;
    while (NULL != pNode)
    {
        memcpy(pChatPDU->chatData+i*FILE_NAME_LEN
               , pNode->caName, FILE_NAME_LEN);
        i++;
        pNode = pNode->pNext;
    }
    pChatPDU->iChatPDULen = iLen;
    pChatPDU->iChatDataLen = g_pHead->iNum * FILE_NAME_LEN;
    pChatPDU->iType = ENUM_TYPE_RESP_FILE_INFO;

    sendDataToClient(sockfd, pChatPDU);
    freePDU(pChatPDU);
    pChatPDU = NULL;
}

static void handleClientUploadFile(ChatPDU *pChatPDU)
{
    if (NULL == pChatPDU)
    {
        return;
    }
    char caPath[64] = FILE_PATH;
    strcat(caPath, pChatPDU->caFileName);
    int fd = openFile(caPath);

    char caBuf[FILE_IO_MAX_LEN+1] = {'\0'};
    memset(caBuf, '\0', FILE_IO_MAX_LEN+1);
    strncpy(caBuf, pChatPDU->chatData, pChatPDU->iChatDataLen);
    lseek(fd, 0, SEEK_END);
    writeDataToFile(fd, caBuf, pChatPDU->iChatDataLen);
    closeFile(fd);
}

static void handleClientDownloadFile(int sockfd, ChatPDU *pChatPDU)
{
    if (NULL != pChatPDU)
    {
        char caPath[64] = FILE_PATH;
        strcat(caPath, pChatPDU->caFileName);
        int fd = openFile(caPath);
        int iFileSize = lseek(fd, 0, SEEK_END);
        int ret = -1;

        int iLen = sizeof(ChatPDU)-sizeof(int)+FILE_IO_MAX_LEN;
        ChatPDU *pChatPDUSend = makeChatPDU(iLen);

        pChatPDUSend->iChatPDULen = iLen;
        pChatPDUSend->iType = ENUM_TYPE_RESP_DOWNLOAD_FILE;
        strcpy(pChatPDUSend->caFileName, pChatPDU->caFileName);
        pChatPDUSend->iFileSize = iFileSize;
        printf("file size = %d\n", pChatPDUSend->iFileSize);
        char caData[FILE_IO_MAX_LEN];
        lseek(fd, 0, SEEK_SET);
        while (ret = read(fd, caData, FILE_IO_MAX_LEN))
        {
            pChatPDUSend->iChatDataLen = ret;
            memcpy(pChatPDUSend->chatData, caData, ret);
            printf("data len = %d\n", ret);
            sendDataToClient(sockfd, pChatPDUSend);
        }
        freePDU(pChatPDU);
        freePDU(pChatPDUSend);
    }
}

static void *handleClient(void *arg)
{
    int sockfd = (int)arg;
    ChatPDU *pChatPDU = NULL;
    int iMsgType = 0;
    while (1)
    {
        /*获得PDU*/
        pChatPDU = readDataFromClient(sockfd);
        if (NULL != pChatPDU)
        {
            /*解析PDU*/
            iMsgType = parsePDU(pChatPDU);
            switch (iMsgType)
            {
            //客户端请求查看所有文件
            case ENUM_TYPE_ASK_FILE_INFO:
                freePDU(pChatPDU);
                pChatPDU = NULL;
                sendFileListToClient(sockfd);
                break;
            //客户端上传文件
            case ENUM_TYPE_UPLOAD_FILE:
                handleClientUploadFile(pChatPDU);
                freePDU(pChatPDU);
                pChatPDU = NULL;
                break;
            //客户端请求下载文件
            case ENUM_TYPE_ASK_DOWNLOAD_FILE:
                handleClientDownloadFile(sockfd, pChatPDU);
                break;
            //客户端修改文件名
            case ENUM_TYPE_RENAME_FILE:
                break;
            //客户端删除文件
            case ENUM_TYPE_DELETE_FILE:
                break;
            default:
                break;
            }
        }
    }
}

int makeSocket()
{
    int sockfd = 0;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd)
    {
        PRINT_ERROR("socket");
        exit(-1);
    }
    return sockfd;
}

void bindSocketAddr(int sockfd)
{
    struct sockaddr_in servaddr;
    //地址协议:ipv4
    servaddr.sin_family = AF_INET;
    //服务器端口
    servaddr.sin_port = htons(8668);
    //服务器ip
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    bzero(&(servaddr.sin_zero), 8);
    int ret = bind(sockfd
                   , (struct sockaddr *)&servaddr
                   , sizeof(struct sockaddr));
    if (-1 == ret)
    {
        PRINT_ERROR("bind");
        exit(-1);
    }
}
void listenClient(int sockfd)
{
    int ret = listen(sockfd, 10);
    if (-1 == ret)
    {
        PRINT_ERROR("listen");
        exit(-1);
    }
}

static void acceptClient(int sockfd)
{
    struct sockaddr_in clientaddr;
    int iLen = sizeof(struct sockaddr);
    int sockClient = 0;
    pthread_t pt;
    int ret = 0;
    while (1)
    {
        printf("accepting client connect...\n");
        //服务器通过sockClient和客户端进行通信
        //clientaddr：用来保存客户端地址等信息
        //accept():阻塞等待客户端的连接
        sockClient = accept(sockfd
                    , (struct sockaddr *)&clientaddr
                    , &iLen);
        printf("after accepted client\n");
        ret = pthread_create(&pt, NULL, handleClient
                             , (void *)sockClient);
        if (0 != ret)
        {
            PRINT_ERROR("pthread_create");
            exit(-1);
        }
//      pthread_detach(pt);
    }
}

void handle(int sockfd)
{
    g_pHead = makeList();
    //scanFileIntoList(g_pHead, FILE_PATH);
    showList(g_pHead);

    acceptClient(sockfd);
}

main(server)

#include "chatServer.h"

int main(void)
{
    int sockfd = -1;
    sockfd = makeSocket();
    bindSocketAddr(sockfd); 
    listenClient(socakfd);
    handle(sockfd);

    return 0;
}

test.c

#include 

int main(void)
{
    printf("%d\n", 24323236 % 4096);

    return 0;
}

你可能感兴趣的:(查看上传下载)

  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • Git常用命令－修改远程仓库地址 猿大师 LinuxJavagitjava
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
  • 冬天短期的暴利小生意有哪些？那些小生意适合新手做？ 一起高省
    短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • mac电脑命令行获取电量 小米人er 我的博客macos命令行
    在macOS上，有几个命令行工具可以用来获取电量信息，最常用的是pmset命令。你可以通过以下方式来查看电池状态和电量信息：查看电池状态：pmset-gbatt这个命令会返回类似下面的输出：Nowdrawingfrom'BatteryPower'-InternalBattery-0(id=1234567)95%;discharging;4:02remainingpresent:true输出中包括电
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • 剧本杀《鲸鱼马戏团》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
    本文为剧本杀《鲸鱼马戏团》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《鲸鱼马戏团》即可获取查看剧本杀《鲸鱼马戏团》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 厦门自由行之第一天: 大苏子在广漂
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
  • openssl+keepalived安装部署 _小亦_ 项目部署keepalivedopenssl
    文章目录OpenSSL安装下载地址编译安装修改系统配置版本Keepalived安装下载地址安装遇到问题安装完成配置文件keepalived运行检查运行状态查看系统日志修改服务service重新加载systemd检查配置文件语法错误OpenSSL安装下载地址考虑到后面设备可能没法连接到外网，所以采用安装包的方式进行部署，下载地址：https://www.openssl.org/source/old/
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 errorreactmongodb数据库
    背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
  • 三人行（六十三） 清风不等明月
    书接上文：虽然大家都认为要进密室看看，但是罗道长还是提醒各位不要轻举妄动。让灵儿这两天也不用在盯着孟琦了，罗道长想从侧面打探一下密室的消息，看看有没有办法把孟琦调走一段时间，这样就有机会进入密室查看了。机会很快就来了，因为月底孟琦要在议事堂商议各堂口的事项。所以有一天的时间他的卧室都是空的。这一天很快就到了，各堂口的负责人都聚集在议事堂，今天孟琦是主角，他当然也是不能缺席的。他们商议的无非是各堂口
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • golang 实现文件上传下载 wangwei830 go
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
  • 剧本杀《暗黑者·七宗欲》复盘详细解析+凶手角色剧透答案真相 VX搜_小燕子复盘
    为了你获得更好的游戏体验，本文仅显示《暗黑者·七宗欲》剧本杀部分真相复盘，获取完整真相复盘只需两步①【微信关注公众号：集美复盘】②回复【暗黑者·七宗欲】即可查看获取哦﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎1、剧本杀《暗黑者·七宗欲》角色介绍朱思俊沙害杜光荣的手法：接到杜光荣的电话之后，朱思俊约对方在地下室见面细聊。朱思俊出门时携带了老冰棍（放在保温杯中）、白砂糖、鱼线
  • 【显示 后台运行 & 的命令】 晨春计 debuglinux服务器运维
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 【Python】tkinter及组件如何使用 小九不懂SAP 我的Python日记python开发语言tkinter
    一、tkinter的应用场景tkinter是Python的标准GUI（图形用户界面）库，它提供了丰富的控件和工具，使得开发者能够轻松创建跨平台的桌面应用程序。以下是一些tkinter的常见应用场景：桌面应用程序开发：开发者可以使用tkinter来创建各种桌面应用程序，如文本编辑器、计算器、图片查看器、游戏等。这些应用程序可以具有复杂的用户界面，包括窗口、按钮、文本框、下拉菜单、滚动条等。数据可视化
  • 剧本杀谁是凶手《红瞳消逝之时》凶手是谁剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
    本文为谁是凶手《红瞳消逝之时》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复谁是凶手《红瞳消逝之时》即可获取查看谁是凶手《红瞳消逝之时》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 用kubedam搭建的k8s证书过期处理方法 我滴鬼鬼呀wks k8s1024程序员节
    kubeadm部署的k8s证书过期1、查看证书过期时间kubeadmalphacertscheck-expiration若证书已经过期无法试用kubectl命令建议修改服务器时间到未过期的时间段2、配置kube-controller-manager.yaml文件cat/etc/kubernetes/manifests/kube-controller-manager.yamlapiVersion:v
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他