萌面大叔2
萌面大叔2

day10

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

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;
        }
    }
}

main.c(client)

#include "chatClient.h"

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

    return 0;
}

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

error.c

#include "error.h"

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(sockfd);
    handle(sockfd);

    return 0;
}

你可能感兴趣的:(day10)

  • 有钱人很会管理他们的钱，穷人很会搞丢他们的钱。 林双_001
    林双晨读笔记day10有钱人很会管理他们的钱，穷人很会搞丢他们的钱。换句更简单的话理解就是有钱人懂的让钱为他们工作，但是穷人只会为钱工作。每天矜矜业业，拿到工资之后很少会划分出一部分收入去投资大脑，所以思维跟不上，也没有让钱为自己工作的意识。而一个人能得到多少钱都是由自己的认知决定的，就是你很难得到你认知以外的钱。即使你侥幸得到了，这个世界也会有成千上万种方式将你的钱收割在你认知范围内。虽然现在还
  • 正向生活行动营 Day10 暖暖的心房
    罗伯特•戴博德《蛤蟆先生去看心理医生》P100、1092022年3️月14日1.生活是可爱的，因为你们是可爱的，我们是可爱的2.你的名字，你的头像都是你真实的社交属性社交平台上其实比较暴露我们每个人的内心的潜意识；名字是一个符号是为了方便别人3.当你意识到你的内在小孩在成长的时候，你的状况就开始变好了，开始学会自我管理，更重要的开始学会奖励自己；4.当一个人对别人没有耐心的时候，代表的是他对自己没
  • SiteServer 学习笔记 Day10 用户中心与用户管理 为风而战 SiteServerSSCMS学习笔记
    1、进入管理系统后，选择“系统管理”->“用户中心”，用户中心中包括：1.1、进入用户中心1.2、用户中心设置1.3、用户中心菜单1.3.1、新增一级菜单：添加任务系统，可以在1.4种看到菜单栏中任务系统。1.3.2、新增下级菜单：选中任务系统，点击右侧的新增下级菜单，可以在任务系统菜单下添加一个新的菜单，如1.4中左侧菜单栏。1.3.3、菜单链接&#
  • Day10健康管理师考试 jingyueyan
    今天感冒发烧，难受随便分享下吧席慕蓉经典名句1.如何让你遇见我，在我最美丽的时刻。《1颗开花的树》2.世间总有1些事，是我们永久没法解释也没法说清的，我必须接受自己的渺小和自己的无能为力。《心灵的对照》3.请不要相信我的美丽也不要相信我的爱情在涂满了油彩的面容之下我有的是颗戏子的心所以千万不要不要把我的悲痛认真也别随着我的表演心碎亲爱的朋友今身今世我只是个戏子永久在他人的故事里流着自己的泪。《席慕
  • 【Day10】5.14一句顶万句 Doris_022
    人与人交往，也就说得着说不着一回事。看到剩下1/4的书，突然很心疼，巧玲(曹青娥)在梦里，梦见她的三个爹，虽时而模糊时而清晰，却都藏着数不尽的苦楚，为着，她开始走出延津，走向她的梦归处，只是现实并不遂人愿，地方还是老地方，岁月已经把一切熟悉的痕迹冲刷干净。不免让人感慨，岁月无情，假若不及时珍惜眼前，回过头沉思留恋，人心也难以安稳，只剩难免些许的遗憾。有些人话稠，有些人话少，但是说得上说不上，求的是
  • CCF-CSP认证考试准备第十天 爱coding的橙子 CCF-CSP认证c++算法数据结构
    ###Day10:1.202206-22.202209-2(先放一下)3.202212-2####1.202206-2:寻宝！大冒险！(枚举，稀疏数组,犯了一个边界判断逻辑错误，只有60，改正即为100)(1)一开始漏了绿化图是0但宝藏图是1的这种情况，但加上去只有60分思路：宝藏图很大，只要存储几个为1的点的坐标即可，有点类似稀疏向量，用set存储即可快速判断一个坐标在宝藏图中是否为1（哈希思想
  • 刻意练习 day10 隔壁v你王叔
    图片发自App图片发自App昨天的偏鸡汤点告诉我们天才是每个人都可以当的，像美国总统一样，只要你有梦想。但在中国你真真的那才叫中国梦。那么真正影响天才的是什么因素呢下面来讨论我们都有这样的经历。从小就学各种课外兴趣班，钢琴象棋奥数也好还是体育运用，我们总会遇到哪些比自己领悟能力强，比一般人学的都快，也就是起步阶段就有优势的人，这种差距产生，让人们认为这孩子现在就领先，以后更是不可限量，这种结论是不
  • 2019-03-13课堂笔记 山有木兮_8adb
    |Day10||作者：赵心驰归档：课堂笔记时间：2019/3/13||快捷键：Ctrl+1标题1Ctrl+2标题2Ctrl+3标题3Ctrl+4标题4Ctrl+5程序代码Ctrl+6正文Ctrl+7实例1-1||格式说明：蓝色字体：注释黄色背景：重要绿色背景：注意|老男孩教育教学核心思想6重：重目标、重思路、重方法、重实践、重习惯、重总结学无止境，老男孩教育成就你人生的起点！联系方式:|网站运维*
  • 【4班4组】Day10 掌握这几招，解决写作没选题的难题 常十七
    图片发自App【学员信息】：413-常十七-小作业6【作业要求】：寻找5个可以写的选题，其中2个勾勒出文章结构、行文策略。【作业如下】：1.人前的锦鲤属性？那其实背后至死方休的咬牙坚持2.掌握这8个方法，就能快速让你升职加薪3.从业十年的常老师，手把手教你如何顺利拿到美国签证4.那个懂事的女孩儿，男朋友又被抢走了5.如何在上坚持日更图片发自App图片发自App
  • day10 做一个生性薄凉之人 芳玉说
    1在工作上尽心尽力，结果上不太如人意当领导扣我分的时候，这是我没有想到的我一个人承受了太多2话不可以说太满，来上班的第一天，就要做好随时离开或者被开除的准备3想学的知识就去学吧，想做的事情也一定要给自己留出时间4这段时间几乎没有了自我，慢慢从这种状态中抽离出来，我就只是我自己，不用去顾虑到任何人5刹那一刻想念老朋友了，很想念的那种，像是放电影一样，时光好快呀
  • #四月主题打卡# Day10 蜗牛君的梦想进行时
    图片发自App✅A4纸清理✅薄荷阅读Day42✅可复制的领导力课程Day1✅专业书阅读45min今天是我小长假后第一天上班每一次放假过后都要有一两天的磨合期今天科室护士长给我推荐了一款适合更年期妈妈的保健品她自己也在吃可以适当补充体内雌激素谢谢你我爱你收到了放假前从娟娟姐那儿买的新书《发现天赋之旅》和前两天同爸爸一起买的手环今天可复制领导力课程第一天听了两堂课和一本书《联盟》做30道题及输出笔记群
  • 入门Java编程的知识点—＞重写（day10） 小星袁 Java基础知识点javapythonlinux
    重点掌握重写的适用性？重写的语法?重点掌握多态是什么？多态-向上造型的语法?多态的意义?重点掌握接口是什么?接口如何语法如何定义?重点掌握引用类型转换有哪些？instanceOf关键字如何用?回顾在昨天的ExtendsDemo测试类中,我们如果想要表示多个学生对象,多个老师对象,多个医生对象,则需要使用数组来完成Student[]students=newStudent[3];students[0]
  • 【万有幸福墙】家务-21天日记day10 熊妈侯蕾
    对于家务，我称不上喜欢，但也不至于不喜欢。单就一件事情本身而言，我们对它的感情是中性的，但因为一些自己赋予的意义，会让它带上不同的感情色彩。我想，大多数人不喜欢家务，可能是因为这些事情既繁琐又劳累，成果还不大显眼，属于典型的“干得不好会被抱怨，做得好别人却觉得是应该的”。相信很多家庭主妇都曾经历过这样的情景：费劲兮兮的干了一天活儿，满心欢喜的等着家人回来表扬一下，结果人家就跟没看见一样；等啊等啊终
  • Day10 总资产周转率 一颗葱er
    前面几天，我们学习了《五大数字力》的第一模块——现金流量，从今天开始来学习第二模块——经营能力。在进入第二模块的学习之前，先总揽五大数字力指标，知道我们目前学习的进度。一、概念现金流量比的是谁的气更长，越长越好。那公司的经营能力比什么？如何判断呢？MJ老师把经营能力翻译成“翻桌率”，怎么样，不理解吧？比如我们去餐厅吃饭，有的饭店非常热闹，他们店里每一张桌子在一顿饭可以接待好几拨客人，而有的餐厅吃饭
  • 每日一书——《查令十字街84号》 Cherry筱
    Day10/2182+Cherry+北京【书籍名称】：《查令十字街84号》——海莲.汉芙图片发自App【整体感受】：我想这本书是因为一部电影引起的热潮，当时记得看完电影就去看，能感受到那份温暖与美好。这次是重拾这本书，依然感受到那纯粹的美好。它主要讲述了1949年海莲与弗兰克.德尔以及书店的其他员工通过书信的形式来记录，一直到1969年这20年间跨越大西洋的深厚友谊。虽是素未谋面，但这份友谊是那样
  • 第13届宇宙公民高效阅读蜕变营 Day10 JinYe
    很多年前，我说过这样一句矛盾的话，你知道为了我的懒惰，我要比别人勤奋多少吗？我从来没解释过为什么会说出这样的话。这句话最初的感悟是2013年环球小姐全球总决赛，那是11月的莫斯科，寒冷无比。每天从早到晚穿着15公分高跟鞋密集训练参加活动，睡眠不足四小时。因为我习惯性动作慢，所以我大概要比别人早起一个小时(早晨五点)来保证我妆面造型的完整度。因为我是干性敏感肌，所以我大概要比别人晚睡一个小时(凌晨两
  • 欧阳锋|Day10感恩日记 庭筠
    1.感恩今天又是新的一天，做到早起并完成朗读和阅读20分钟，感恩自己的坚持。2.感恩今天的公交车准时准点的到达，让我提前到达目的地。3.感恩今天的天气，不冷不热，舒适适合工作适合生活。4.感恩今天地铁站工作人员，限流控流，保证我们能井然有序的上班，不至于拥挤。5.感恩今天早上群里同学的相互问好，相互赋能，充满正能量的一天开始了。6.感恩今天的电梯保洁员，每天都对电梯消毒，更换防护膜。7.感恩今天的
  • day10作业 上邪5415
    编写千峰学生管理系统。logon_student_account={}student_info_dict={}login_count_student_info_dict={}whileTrue:str1='welcomeQianFengstudentmanagersystem'print(str1)print('1.Login登录')print('2.logon注册')print('3.Quit'
  • LeetCode 练习 day10 小黑DX leetcodejavalinux
    14.最长公共前缀编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串“”。示例1：输入：strs=[“flower”,“flow”,“flight”]输出：“fl”示例2：输入：strs=[“dog”,“racecar”,“car”]输出：“”解释：输入不存在公共前缀。classSolution{publicStringlongestCommonPrefix(Strin
  • 【1班2组】+Day10《如何解决写作没选题的难题？》 王锡
    【学员信息】215-王锡-小作业06【作业要求】:引子其实就是我们的选题，那么我们可以从一件事，一部作品，一个问题，一个人，一个工具、想法等等，去进行选择，方法在课程里老师有讲。作业模板如下：【作业如下】选题1：刘润在公众号中转发了一篇写于自己2013年4月28日的告别微软的离职信。启发：离职不离初心心，感恩过去，憧憬未来。标题：《刘润：一封被阅读91.5万次的离职信》文章结构：叙述型结构选题2：
  • 读书打卡^_^Day10《绝佳体验》共读感悟 南城有风
    联系是接触和关系的轴心点。是一个长期关系建立的信任、自信的方式。就是你能为别人带去什么价值。1.良好沟通。通过肢体动作、文字，让顾客在体验过程中感知到被重视。2.有意性。创造新的有自己的术语，用于自身的运营，比如行动营的老铁，六项精进等专属词汇。3.积极肯定。让学员不要感到被忽视，要多次肯定他们，鼓励他们的优良品质和积极向上。4.加深学习。为学员提供服务、体验，首先要保证自己对产品的全面了解。自己
  • 群买买写作营输出打卡Day10 草原夜语
    阅读书籍《写作7堂课》字数:纸书89-98页R:快速集中注意力，进入心流状态的5个关键1.你必须从内心接纳，这件事你非做不可2.要把任务难度设置为跳一跳够得着的难度3.给完成任务的自己一个奖励4.准备进入心流状态之前给自己一个暗示信号5.你需要一个不被干扰的环境，而不是要求自己心无旁骛I：1.只有脑中有非做不可的念头，自己才会有源源不断的动力，否则很容易拖延甚至放弃。2.对于触手可及的东西，人们更
  • Hi小姐复盘Day10―生活的小美好 小拾贰_609d
    记录（what）有时候会觉得自己很幸运，幸运遇到对的人。和同宿舍的室友一起去吃饭，庆祝我们彼此都找到工作。其实在这个陌生的城市里，遇到了一个可爱的姑娘，会陪我逛街，帮我挑衣服，和我一起我跑步，跟我我聊天，会做饭给我吃，会带我出去玩。真的，还好有她，我都觉得自己的生活不一样了，甚至丰富了很多。反思（why）对于我这种死宅的人来说，毎天做的事情就是早上上班，晚上下班，早点回家洗洗睡了。一天就是那种正常
  • 每日正念Day10——由内而外的感受 瑞雪育儿小课堂
    伟大的小说家写道，至关重要的是人类正在死去。我们像一棵被连根拔起的大树，根裸露在空气中，我们必须把自己再次植入宇宙，当我们以正念的方式体验我们身体，实际感觉是我们就如同把自己种植在宇宙中。在过去的课程中，我们开始学习如何由内而外的感觉身体，今天我们会对身体进行正念的检视，找到我们最容易体验到身体感受的那些地方，找到那些你认为是我们的根的地方。它像树根一样露在空气中，这些地方我们很少涉足。当我们主要
  • 蓝桥杯day10刷题日记 jia_jia_LL 蓝桥杯蓝桥杯算法图论dfs刷题笔记数据结构
    P8604[蓝桥杯2013国C]危险系数思路：dfs，用深度优先搜索查找一次所有的线路，过程中记录每个点走过的次数，最后在与总路线数比较，相同即为每次必过的点，即关键点#includeusingnamespacestd;intn,m;inta[1010][1010],b[1010];intu,v;intcnt[1010],sum,ans;voiddfs(intx){if(x==v){sum++;f
  • 2022/3/16 小乖 每日复盘 day10 小乖在成长
    2022/3/16小乖#每日复盘day101.做事情的时候，到底是一个什么态度，是在应付为了完成事情而完成，还是说有负责的态度要把事情做好达到什么样的目标。反思我自己，经常是前期干劲十足，后期就成了应付状态。时刻提醒自己，我为什么做这件事，真正做个共建者的态度。2.忙，但不要瞎忙我要好好学习切换视角：青蛙视角（聚焦当下）和老鹰视角（放宽视野）聚焦当下--抽离出(判断行动的价值)--扎实前行+看到自
  • 【LeetCode+JavaGuide打卡】Day10|232. 用栈实现队列、225. 用队列实现栈 WhoAmI\ leetcode算法职场和发展
    学习目标：232.用栈实现队列225.用队列实现栈Java集合常见面试题总结(上)学习内容：来源：JavaGuideQueue是单端队列，只能从一端插入元素，另一端删除元素，实现上一般遵循先进先出（FIFO）规则。Deque是双端队列，在队列的两端均可以插入或删除元素。Deque还提供有push()和pop()等其他方法，可用于模拟栈ArrayDeque和LinkedList都实现了Deque接口
  • Day10/100每天坚持无意识写作100天 一言二丫
    我本可以忍受奴役，假如我不曾知道自由。“被焊在笼子里的人”：你看啊，外面的阳光多好，可你就是出不去…笼子外的人：我多想进去这个笼子里，可以避风挡雨…在不适合的环境里越努力越畸形，被焊在了笼子里，即使你有翅膀又样…从昨天早上接到工作上的催命电话开始，我一直在克制自己的情绪，深呼吸，告诉自己不要去抱怨。临上班前一直在深呼吸。没想到晚上下班的时候，终究还是绷不住了，无数次的问自己，我真的需要这份工作吗？
  • 共读《真希望我父母读过这本书》day10 李洁_7c3f
    2022.02.23p104－120页分娩和最初的关系规划分娩花点时间做些研究是值得的，你应该为你认为最理想，最少创伤的分娩方式做计划就会让你和宝宝有一个好的开始。讲述分娩经验讲述分娩经验很重要，可以重新获得一种平衡感。你所能做的，是朝着你想要的方向前进，然后灵活地因应你无法控制的状况。吃奶的本能婴儿天生就有寻找乳头的本能，最明显的反应就是用哭告诉你他需要你的陪伴，拥抱或喂食等。最初的关系你需要接
  • 跑起步，动起肩 DAY10 肆意洒脱
    想到当天的工作量，跑步上班还是心里有些发怵。不同于前段时间上班期间活动少，且大多时间都是不紧不慢，或者索性坐着。先跑着再说吧！受台风“轩岚诺”的影响，天空依然飘着毛毛细雨，原本紧张不安的心在跑起步跟随着音乐的节奏的时候，慢慢欢快起来。最开心的事情，莫过于回到科里，医生、护士、护工以及内勤人员见到我的归来，既激动又热情，一位医生形容到：“夹道欢迎。”就连按疗程治疗，反复入院的病人见到我都说：“我上次
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他