cvitool 1.0.7 → 1.0.71

package/build/src/cutil.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Encoding } from 'crypto';
 interface randomStringOptions {
     special?: boolean;
     lowercase?: boolean;
@@ -6,4 +9,8 @@ interface randomStringOptions {
     specials?: string;
 }
 declare function randomString(length: number, options?: randomStringOptions): string;
-export { randomStringOptions, randomString };
+declare function encryptCBC(data: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, inputEncoding?: Encoding): string;
+declare function decryptCBC(encryptData: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, outputEncoding?: Encoding): string;
+declare function md5(data: string, inputEncoding?: Encoding): string;
+declare function execCmdCommand(command: string): Promise<unknown>;
+export { randomStringOptions, randomString, encryptCBC, decryptCBC, md5, execCmdCommand };

package/build/src/cutil.js

@@ -1,7 +1,17 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomString = void 0;
+exports.execCmdCommand = exports.md5 = exports.decryptCBC = exports.encryptCBC = exports.randomString = void 0;
 const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
 function randomString(length, options) {
     let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
     if (specials) {
@@ -35,3 +45,50 @@ function randomString(length, options) {
     return result;
 }
 exports.randomString = randomString;
+function encryptCBC(data, length, key, iv, inputEncoding = 'utf-8') {
+    const algorithm = `aes-${length}-cbc`;
+    const cipher = (0, crypto_1.createCipheriv)(algorithm, key, iv);
+    let crypted = cipher.update(data, inputEncoding, 'hex');
+    crypted += cipher.final('hex');
+    return crypted;
+}
+exports.encryptCBC = encryptCBC;
+;
+function decryptCBC(encryptData, length, key, iv, outputEncoding = 'utf-8') {
+    const algorithm = `aes-${length}-cbc`;
+    const decipher = (0, crypto_1.createDecipheriv)(algorithm, key, iv);
+    let decrypted = decipher.update(encryptData, 'hex', outputEncoding);
+    decrypted += decipher.final(outputEncoding);
+    return decrypted;
+}
+exports.decryptCBC = decryptCBC;
+;
+function md5(data, inputEncoding = 'utf-8') {
+    return (0, crypto_1.createHash)('md5').update(data, inputEncoding).digest('hex');
+}
+exports.md5 = md5;
+function execCmdCommand(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const commandList = command.split(' ');
+        const commandName = commandList.splice(0, 1);
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const cmd = (0, child_process_1.spawn)(commandName[0], commandList, { stdio: 'pipe', shell: true });
+            cmd.stdout.on('data', chunk => {
+                chunks.push(chunk);
+            });
+            cmd.stderr.on('data', chunk => {
+                chunks.push(chunk);
+            });
+            cmd.on('exit', (code) => {
+                const result = Buffer.concat(chunks).toString();
+                if (code !== 0) {
+                    reject(result);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+    });
+}
+exports.execCmdCommand = execCmdCommand;

package/build/src/hgo.d.ts

@@ -12,14 +12,16 @@ interface CustomObject {
 }
 interface baseReqOptions {
     timeout?: number;
-    method?: Method;
     agent?: http.Agent | https.Agent;
     headers?: {
         [key: string]: string;
     };
     resType?: ResType;
+    connectTimeOut?: number;
+    readTimeOut?: number;
 }
 interface reqOptions extends baseReqOptions {
+    method?: Method;
     query?: {
         [key: string]: string;
     };
@@ -28,9 +30,11 @@ interface reqOptions extends baseReqOptions {
     };
 }
 interface reqSendBufferOptions extends baseReqOptions {
+    method?: Method;
     buffer: Buffer;
 }
 interface reqSendStreamOptions extends baseReqOptions {
+    method?: Method;
     stream: ReadStream;
 }
 interface reqSendMultiPartOptions extends baseReqOptions {
@@ -45,4 +49,8 @@ declare function request(url: string, options?: reqOptions): Promise<ResData>;
 declare function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData>;
 declare function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData>;
 declare function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData>;
-export { reqOptions, reqSendBufferOptions, reqSendStreamOptions, reqSendMultiPartOptions, ResData, request, reqSendBuffer, reqSendStream, reqSendMultiPart, };
+declare function get(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>;
+declare function post(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>;
+declare function put(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>;
+declare function head(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>;
+export { reqOptions, reqSendBufferOptions, reqSendStreamOptions, reqSendMultiPartOptions, ResData, request, reqSendBuffer, reqSendStream, reqSendMultiPart, get, post, put, head };

package/build/src/hgo.js

@@ -9,19 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reqSendMultiPart = exports.reqSendStream = exports.reqSendBuffer = exports.request = void 0;
+exports.head = exports.put = exports.post = exports.get = exports.reqSendMultiPart = exports.reqSendStream = exports.reqSendBuffer = exports.request = void 0;
 const querystring = require("querystring");
 const https = require("https");
 const http = require("http");
-function getTimeOutMessage(timeout) {
-    return `request timeout of ${timeout} ms`;
+function buildTimeOutErr(type, timeout, reqUrl) {
+    const err = new Error();
+    err.code = 'TimeOut';
+    err.name = `${type}Error`;
+    err.message = `${type} for ${timeout} ms`;
+    err.reqUrl = reqUrl;
+    return err;
 }
 function getProtocol(url) {
     return url.startsWith('https') ? https : http;
 }
 function request(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json' } = options || {};
+        let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut } = options || {};
+        if (timeout && !(connectTimeOut && readTimeOut)) {
+            connectTimeOut = timeout;
+            readTimeOut = timeout;
+        }
         if (Object.keys(query).length !== 0) {
             if (url.indexOf('?') > -1) {
                 url = url + '&' + querystring.stringify(query);
@@ -33,22 +42,25 @@ function request(url, options) {
         const data = JSON.stringify(body);
         const protocol = getProtocol(url);
         const isbodyEmpty = Object.keys(body).length === 0;
-        const baseHeaders = {
-            'Content-Type': 'application/json;charset=utf-8',
-            'Content-length': isbodyEmpty ? 0 : Buffer.byteLength(data)
-        };
+        let baseHeaders = {};
+        if (!isbodyEmpty) {
+            baseHeaders = {
+                'Content-Type': 'application/json; charset=utf-8',
+                'Content-length': Buffer.byteLength(data)
+            };
+        }
         return new Promise((resolve, reject) => {
             const req = protocol.request(url, {
-                timeout,
+                timeout: connectTimeOut,
                 headers: Object.assign(headers, baseHeaders),
                 method,
                 agent
             }, res => {
-                resHandld(res, resolve, reject, resType, method);
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
             });
             req.on('timeout', () => {
                 req.destroy();
-                reject(new Error(getTimeOutMessage(timeout)));
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
             });
             req.on('error', e => {
                 req.destroy();
@@ -72,20 +84,24 @@ function request(url, options) {
 exports.request = request;
 function reqSendBuffer(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { timeout = 60000, headers = {}, buffer, method = 'post', agent, resType = 'json' } = options;
+        let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        if (timeout && !(connectTimeOut && readTimeOut)) {
+            connectTimeOut = timeout;
+            readTimeOut = timeout;
+        }
         const protocol = getProtocol(url);
         return new Promise((resolve, reject) => {
             const req = protocol.request(url, {
-                timeout,
+                timeout: connectTimeOut,
                 headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
                 method,
                 agent
             }, res => {
-                resHandld(res, resolve, reject, resType, method);
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
             });
             req.on('timeout', () => {
                 req.destroy();
-                reject(new Error(getTimeOutMessage(timeout)));
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
             });
             req.on('error', e => {
                 req.destroy();
@@ -104,7 +120,11 @@ function reqSendBuffer(url, options) {
 exports.reqSendBuffer = reqSendBuffer;
 function reqSendStream(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { timeout = 60000, method = 'post', stream, headers = {}, agent, resType = 'json' } = options;
+        let { timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        if (timeout && !(connectTimeOut && readTimeOut)) {
+            connectTimeOut = timeout;
+            readTimeOut = timeout;
+        }
         const protocol = getProtocol(url);
         return new Promise((resolve, reject) => {
             const baseHeaders = {
@@ -113,16 +133,16 @@ function reqSendStream(url, options) {
                 Connection: 'keep-alive'
             };
             const req = protocol.request(url, {
-                timeout,
+                timeout: connectTimeOut,
                 headers: Object.assign(headers, baseHeaders),
                 method,
                 agent
             }, res => {
-                resHandld(res, resolve, reject, resType, method);
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
             });
             req.on('timeout', () => {
                 req.destroy();
-                reject(new Error(getTimeOutMessage(timeout)));
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
             });
             req.on('error', e => {
                 req.destroy();
@@ -151,20 +171,24 @@ function reqSendStream(url, options) {
 exports.reqSendStream = reqSendStream;
 function reqSendMultiPart(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { timeout = 60000, headers = {}, form, agent, resType = 'json' } = options;
+        let { timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        if (timeout && !(connectTimeOut && readTimeOut)) {
+            connectTimeOut = timeout;
+            readTimeOut = timeout;
+        }
         const protocol = getProtocol(url);
         return new Promise((resolve, reject) => {
             const req = protocol.request(url, {
-                timeout,
+                timeout: connectTimeOut,
                 headers: Object.assign(headers, Object.assign({}, form.getHeaders())),
                 method: 'post',
                 agent
             }, res => {
-                resHandld(res, resolve, reject, resType, 'post');
+                resHandld(res, resolve, reject, resType, 'post', readTimeOut, req);
             });
             req.on('timeout', () => {
                 req.destroy();
-                reject(new Error(getTimeOutMessage(timeout)));
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
             });
             req.on('error', e => {
                 req.destroy();
@@ -183,7 +207,7 @@ function reqSendMultiPart(url, options) {
     });
 }
 exports.reqSendMultiPart = reqSendMultiPart;
-function resHandld(res, resolve, reject, resType, method) {
+function resHandld(res, resolve, reject, resType, method, readTimeOut, req) {
     const reqUrl = `${res.req.protocol}//${res.req.host}${res.req.path}`;
     const resHeaders = {};
     for (let i = 0; i < res.rawHeaders.length; i += 2) {
@@ -193,9 +217,12 @@ function resHandld(res, resolve, reject, resType, method) {
         }
     }
     if (res.statusCode >= 400) {
-        errHandle(reject, res, reqUrl, resHeaders);
+        errHandle(reject, res, reqUrl, resHeaders, readTimeOut, req);
         return;
     }
+    successHandle(resolve, reject, res, resType, method, reqUrl, resHeaders, readTimeOut, req);
+}
+function successHandle(resolve, reject, res, resType, method, reqUrl, resHeaders, readTimeOut, req) {
     const resData = {
         reqUrl,
         resHeaders,
@@ -210,56 +237,112 @@ function resHandld(res, resolve, reject, resType, method) {
         resolve(resData);
         return;
     }
+    let isReadTimeOut = false;
+    let isReadFinished = false;
+    let readTimer;
     let resBody;
     const chunks = [];
+    res.once('data', () => {
+        readTimer = setTimeout(() => {
+            if (!isReadFinished) {
+                isReadTimeOut = true;
+                req.destroy();
+                reject(buildTimeOutErr('readTimeOut', readTimeOut, reqUrl));
+            }
+        }, readTimeOut);
+    });
     res.on('data', chunk => {
         chunks.push(chunk);
     });
     res.on('end', () => {
-        const buffer = Buffer.concat(chunks);
-        if (resType === 'buffer') {
-            resBody = buffer;
-        }
-        else {
-            const responseStr = buffer.toString();
-            if (resType === 'text') {
-                resBody = responseStr;
+        if (!isReadTimeOut) {
+            const buffer = Buffer.concat(chunks);
+            if (resType === 'buffer') {
+                resBody = buffer;
             }
             else {
-                try {
-                    resBody = JSON.parse(responseStr);
-                }
-                catch (e) {
+                const responseStr = buffer.toString();
+                if (resType === 'text') {
                     resBody = responseStr;
                 }
+                else {
+                    try {
+                        resBody = JSON.parse(responseStr);
+                    }
+                    catch (e) {
+                        resBody = responseStr;
+                    }
+                }
             }
+            resData.resBody = resBody;
+            isReadFinished = true;
+            clearTimeout(readTimer);
+            resolve(resData);
         }
-        resData.resBody = resBody;
-        resolve(resData);
     });
 }
-function errHandle(reject, res, reqUrl, resHeaders) {
+function errHandle(reject, res, reqUrl, resHeaders, readTimeOut, req) {
+    let isReadTimeOut = false;
+    let isReadFinished = false;
+    let readTimer;
     const chunks = [];
+    res.once('data', () => {
+        readTimer = setTimeout(() => {
+            if (!isReadFinished) {
+                isReadTimeOut = true;
+                req.destroy();
+                reject(buildTimeOutErr('readTimeOut', readTimeOut, reqUrl));
+            }
+        }, readTimeOut);
+    });
     res.on('data', chunk => {
         chunks.push(chunk);
     });
     res.on('end', () => {
-        const buffer = Buffer.concat(chunks);
-        const resData = buffer.toString();
-        let resBody;
-        try {
-            resBody = JSON.parse(resData);
-        }
-        catch (e) {
-            resBody = resData;
+        if (!isReadTimeOut) {
+            const buffer = Buffer.concat(chunks);
+            const resData = buffer.toString();
+            let resBody;
+            try {
+                resBody = JSON.parse(resData);
+            }
+            catch (e) {
+                resBody = resData;
+            }
+            const err = new Error();
+            err.code = res.statusCode;
+            err.name = 'statusCodeError';
+            err.message = `${res.statusCode}|${res.statusMessage}`;
+            err.resBody = resBody;
+            err.reqUrl = reqUrl;
+            err.resHeaders = resHeaders;
+            isReadFinished = true;
+            clearTimeout(readTimer);
+            reject(err);
         }
-        const err = new Error();
-        err.code = res.statusCode;
-        err.name = 'statusCodeError';
-        err.message = `${res.statusCode}|${res.statusMessage}`;
-        err.resBody = resBody;
-        err.reqUrl = reqUrl;
-        err.resHeaders = resHeaders;
-        reject(err);
     });
 }
+function get(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return request(url, Object.assign(Object.assign({}, options), { method: 'get' }));
+    });
+}
+exports.get = get;
+function post(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return request(url, Object.assign(Object.assign({}, options), { method: 'post' }));
+    });
+}
+exports.post = post;
+function put(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return request(url, Object.assign(Object.assign({}, options), { method: 'put' }));
+    });
+}
+exports.put = put;
+function head(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return request(url, Object.assign(Object.assign({}, options), { method: 'head' }));
+    });
+}
+exports.head = head;

package/index.d.ts

@@ -1,4 +1,5 @@
 import { ReadStream, WriteStream } from 'fs';
+import { Encoding } from 'crypto';
 
 import {
     reqOptions,
@@ -17,6 +18,30 @@ import {
 } from './src/cutil';
 
 interface Hgo {
+    /**
+     * request through get
+     * @param url 
+     * @param options 
+     */
+    get(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>,
+    /**
+     * request through post
+     * @param url 
+     * @param options 
+     */
+    post(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>,
+    /**
+     * request through put
+     * @param url 
+     * @param options 
+     */
+    put(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>,
+    /**
+     * request through head
+     * @param url 
+     * @param options 
+     */
+    head(url: string, options?: Omit<reqOptions, 'method'>): Promise<ResData>,
     /**
      * 发出普通请求
      * @param url 
@@ -66,6 +91,35 @@ interface Cutil {
      * @param options 
      */
     randomString(length: number, options?: randomStringOptions): string
+    /**
+     * 以CBC算法进行对称加密
+     * @param data 待加密数据
+     * @param length 算法长度(秘钥需要按照这个长度输入)
+     * @param key 秘钥
+     * @param iv 偏移量(16字节)
+     * @param inputEncoding 输入编码(默认utf-8)
+     */
+    encryptCBC(data: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, inputEncoding?: Encoding): string
+    /**
+     * 以CBC算法进行对称解密
+     * @param encryptData 待解密数据
+     * @param length 算法长度(秘钥需要按照这个长度输入)
+     * @param key 秘钥
+     * @param iv 偏移量(16字节)
+     * @param outputEncoding 输出编码(默认utf-8)
+     */
+    decryptCBC(encryptData: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, outputEncoding?: Encoding): string
+    /**
+     * md5加密
+     * @param data 待加密数据
+     * @param inputEncoding 输入编码
+     */
+    md5(data: string, inputEncoding?: Encoding): string
+    /**
+     * 调用终端执行命令
+     * @param command 
+     */
+    execCmdCommand(command: string): string
 }
 
 declare const hgo: Hgo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvitool",
-  "version": "1.0.7",
+  "version": "1.0.71",
   "description": "cvitool",
   "main": "index.js",
   "scripts": {

package/src/cutil.ts

@@ -1,4 +1,13 @@
-import { randomInt } from 'crypto';
+import {
+    randomInt,
+    createCipheriv,
+    createDecipheriv,
+    createHash,
+    Encoding
+} from 'crypto';
+import {
+    spawn
+} from 'child_process';
 
 interface randomStringOptions {
     special?: boolean,
@@ -41,7 +50,54 @@ function randomString(length: number, options?: randomStringOptions) {
     return result;
 }
 
+function encryptCBC(data: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, inputEncoding: Encoding = 'utf-8') {
+    const algorithm = `aes-${length}-cbc`;
+    const cipher = createCipheriv(algorithm, key, iv);
+    let crypted = cipher.update(data, inputEncoding, 'hex');
+    crypted += cipher.final('hex');
+    return crypted;
+};
+
+function decryptCBC(encryptData: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, outputEncoding: Encoding = 'utf-8') {
+    const algorithm = `aes-${length}-cbc`;
+    const decipher = createDecipheriv(algorithm, key, iv);
+    let decrypted = decipher.update(encryptData, 'hex', outputEncoding);
+    decrypted += decipher.final(outputEncoding);
+    return decrypted;
+};
+
+function md5(data: string, inputEncoding: Encoding = 'utf-8') {
+    return createHash('md5').update(data, inputEncoding).digest('hex');
+}
+
+async function execCmdCommand(command: string) {
+    const commandList = command.split(' ');
+    const commandName = commandList.splice(0, 1);
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const cmd = spawn(commandName[0], commandList, { stdio: 'pipe', shell: true });
+        cmd.stdout.on('data', chunk => {
+            chunks.push(chunk);
+        });
+        cmd.stderr.on('data', chunk => {
+            chunks.push(chunk);
+        });
+        cmd.on('exit', (code) => {
+            const result = Buffer.concat(chunks).toString();
+            if (code !== 0) {
+                reject(result);
+                return;
+            }
+            resolve(result);
+        });
+    });
+}
+
 export {
     randomStringOptions,
-    randomString
+    randomString,
+    encryptCBC,
+    decryptCBC,
+    md5,
+    execCmdCommand
 };

package/src/hgo.ts

@@ -12,15 +12,17 @@ interface CustomObject {
 
 interface baseReqOptions {
     timeout?: number,
-    method?: Method,
     agent?: http.Agent | https.Agent,
     headers?: {
         [key: string]: string
     },
-    resType?: ResType
+    resType?: ResType,
+    connectTimeOut?: number,
+    readTimeOut?: number,
 }
 
 interface reqOptions extends baseReqOptions {
+    method?: Method,
     query?: {
         [key: string]: string
     },
@@ -30,10 +32,12 @@ interface reqOptions extends baseReqOptions {
 }
 
 interface reqSendBufferOptions extends baseReqOptions {
+    method?: Method,
     buffer: Buffer
 }
 
 interface reqSendStreamOptions extends baseReqOptions {
+    method?: Method,
     stream: ReadStream
 }
 
@@ -47,8 +51,13 @@ interface ResData {
     resBody: http.IncomingMessage | CustomObject | string | Buffer | null
 }
 
-function getTimeOutMessage(timeout: number): string {
-    return `request timeout of ${timeout} ms`;
+function buildTimeOutErr(type: 'connectTimeOut' | 'readTimeOut', timeout: number, reqUrl?: string) {
+    const err: any = new Error();
+    err.code = 'TimeOut';
+    err.name = `${type}Error`;
+    err.message = `${type} for ${timeout} ms`;
+    err.reqUrl = reqUrl;
+    return err as Error;
 }
 
 function getProtocol(url: string) {
@@ -56,7 +65,11 @@ function getProtocol(url: string) {
 }
 
 async function request(url: string, options?: reqOptions): Promise<ResData> {
-    const { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json' } = options || {};
+    let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut } = options || {};
+    if (timeout && !(connectTimeOut && readTimeOut)) {
+        connectTimeOut = timeout;
+        readTimeOut = timeout;
+    }
     if (Object.keys(query).length !== 0) {
         if (url.indexOf('?') > -1) {
             url = url + '&' + querystring.stringify(query);
@@ -67,22 +80,25 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
     const data = JSON.stringify(body);
     const protocol = getProtocol(url);
     const isbodyEmpty = Object.keys(body).length === 0;
-    const baseHeaders = {
-        'Content-Type': 'application/json;charset=utf-8',
-        'Content-length': isbodyEmpty ? 0 : Buffer.byteLength(data)
-    };
+    let baseHeaders: CustomObject = {};
+    if (!isbodyEmpty) {
+        baseHeaders = {
+            'Content-Type': 'application/json; charset=utf-8',
+            'Content-length': Buffer.byteLength(data)
+        };
+    }
     return new Promise((resolve, reject) => {
         const req = protocol.request(url, {
-            timeout,
+            timeout: connectTimeOut,
             headers: Object.assign(headers, baseHeaders),
             method,
             agent
         }, res => {
-            resHandld(res, resolve, reject, resType, method);
+            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
         });
         req.on('timeout', () => {
             req.destroy();
-            reject(new Error(getTimeOutMessage(timeout)));
+            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
         });
         req.on('error', e => {
             req.destroy();
@@ -103,20 +119,24 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
 }
 
 async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData> {
-    const { timeout = 60000, headers = {}, buffer, method = 'post', agent, resType = 'json' } = options;
+    let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    if (timeout && !(connectTimeOut && readTimeOut)) {
+        connectTimeOut = timeout;
+        readTimeOut = timeout;
+    }
     const protocol = getProtocol(url);
     return new Promise((resolve, reject) => {
         const req = protocol.request(url, {
-            timeout,
+            timeout: connectTimeOut,
             headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
             method,
             agent
         }, res => {
-            resHandld(res, resolve, reject, resType, method);
+            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
         });
         req.on('timeout', () => {
             req.destroy();
-            reject(new Error(getTimeOutMessage(timeout)));
+            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
         });
         req.on('error', e => {
             req.destroy();
@@ -133,7 +153,11 @@ async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promis
 }
 
 async function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData> {
-    const { timeout = 60000, method = 'post', stream, headers = {}, agent, resType = 'json' } = options;
+    let { timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    if (timeout && !(connectTimeOut && readTimeOut)) {
+        connectTimeOut = timeout;
+        readTimeOut = timeout;
+    }
     const protocol = getProtocol(url);
     return new Promise((resolve, reject) => {
         const baseHeaders = {
@@ -142,16 +166,16 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
             Connection: 'keep-alive'
         };
         const req = protocol.request(url, {
-            timeout,
+            timeout: connectTimeOut,
             headers: Object.assign(headers, baseHeaders),
             method,
             agent
         }, res => {
-            resHandld(res, resolve, reject, resType, method);
+            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
         });
         req.on('timeout', () => {
             req.destroy();
-            reject(new Error(getTimeOutMessage(timeout)));
+            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
         });
         req.on('error', e => {
             req.destroy();
@@ -178,20 +202,24 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
 }
 
 async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData> {
-    const { timeout = 60000, headers = {}, form, agent, resType = 'json' } = options;
+    let { timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    if (timeout && !(connectTimeOut && readTimeOut)) {
+        connectTimeOut = timeout;
+        readTimeOut = timeout;
+    }
     const protocol = getProtocol(url);
     return new Promise((resolve, reject) => {
         const req = protocol.request(url, {
-            timeout,
+            timeout: connectTimeOut,
             headers: Object.assign(headers, { ...form.getHeaders() }),
             method: 'post',
             agent
         }, res => {
-            resHandld(res, resolve, reject, resType, 'post');
+            resHandld(res, resolve, reject, resType, 'post', readTimeOut, req);
         });
         req.on('timeout', () => {
             req.destroy();
-            reject(new Error(getTimeOutMessage(timeout)));
+            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
         });
         req.on('error', e => {
             req.destroy();
@@ -209,7 +237,7 @@ async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions):
     });
 }
 
-function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method) {
+function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method, readTimeOut: number, req: http.ClientRequest) {
     const reqUrl = `${(res as any).req.protocol}//${(res as any).req.host}${(res as any).req.path}`;
     const resHeaders: CustomObject = {};
     for (let i = 0; i < res.rawHeaders.length; i += 2) {
@@ -219,9 +247,13 @@ function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType
         }
     }
     if (res.statusCode >= 400) {
-        errHandle(reject, res, reqUrl, resHeaders);
+        errHandle(reject, res, reqUrl, resHeaders, readTimeOut, req);
         return;
     }
+    successHandle(resolve, reject, res, resType, method, reqUrl, resHeaders, readTimeOut, req);
+}
+
+function successHandle(resolve: any, reject: any, res: http.IncomingMessage, resType: ResType, method: Method, reqUrl: string, resHeaders: CustomObject, readTimeOut: number, req: http.ClientRequest) {
     const resData = {
         reqUrl,
         resHeaders,
@@ -236,57 +268,105 @@ function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType
         resolve(resData);
         return;
     }
+    let isReadTimeOut = false;
+    let isReadFinished = false;
+    let readTimer: any;
     let resBody: Buffer | object | string;
     const chunks = [];
+    res.once('data', () => {
+        readTimer = setTimeout(() => {
+            if (!isReadFinished) {
+                isReadTimeOut = true;
+                req.destroy();
+                reject(buildTimeOutErr('readTimeOut', readTimeOut, reqUrl));
+            }
+        }, readTimeOut);
+    });
     res.on('data', chunk => {
         chunks.push(chunk);
     });
     res.on('end', () => {
-        const buffer = Buffer.concat(chunks);
-        if (resType === 'buffer') {
-            resBody = buffer;
-        } else {
-            const responseStr = buffer.toString();
-            if (resType === 'text') {
-                resBody = responseStr;
+        if (!isReadTimeOut) {
+            const buffer = Buffer.concat(chunks);
+            if (resType === 'buffer') {
+                resBody = buffer;
             } else {
-                try {
-                    resBody = JSON.parse(responseStr);
-                } catch (e) {
+                const responseStr = buffer.toString();
+                if (resType === 'text') {
                     resBody = responseStr;
+                } else {
+                    try {
+                        resBody = JSON.parse(responseStr);
+                    } catch (e) {
+                        resBody = responseStr;
+                    }
                 }
             }
+            resData.resBody = resBody;
+            isReadFinished = true;
+            clearTimeout(readTimer);
+            resolve(resData);
         }
-        resData.resBody = resBody;
-        resolve(resData);
     });
 }
 
-function errHandle(reject: any, res: http.IncomingMessage, reqUrl: string, resHeaders: CustomObject) {
+function errHandle(reject: any, res: http.IncomingMessage, reqUrl: string, resHeaders: CustomObject, readTimeOut: number, req: http.ClientRequest) {
+    let isReadTimeOut = false;
+    let isReadFinished = false;
+    let readTimer: any;
     const chunks = [];
+    res.once('data', () => {
+        readTimer = setTimeout(() => {
+            if (!isReadFinished) {
+                isReadTimeOut = true;
+                req.destroy();
+                reject(buildTimeOutErr('readTimeOut', readTimeOut, reqUrl));
+            }
+        }, readTimeOut);
+    });
     res.on('data', chunk => {
         chunks.push(chunk);
     });
     res.on('end', () => {
-        const buffer = Buffer.concat(chunks);
-        const resData = buffer.toString();
-        let resBody: object | string;
-        try {
-            resBody = JSON.parse(resData);
-        } catch (e) {
-            resBody = resData;
+        if (!isReadTimeOut) {
+            const buffer = Buffer.concat(chunks);
+            const resData = buffer.toString();
+            let resBody: object | string;
+            try {
+                resBody = JSON.parse(resData);
+            } catch (e) {
+                resBody = resData;
+            }
+            const err: any = new Error();
+            err.code = res.statusCode;
+            err.name = 'statusCodeError';
+            err.message = `${res.statusCode}|${res.statusMessage}`;
+            err.resBody = resBody;
+            err.reqUrl = reqUrl;
+            err.resHeaders = resHeaders;
+            isReadFinished = true;
+            clearTimeout(readTimer);
+            reject(err);
         }
-        const err: any = new Error();
-        err.code = res.statusCode;
-        err.name = 'statusCodeError';
-        err.message = `${res.statusCode}|${res.statusMessage}`;
-        err.resBody = resBody;
-        err.reqUrl = reqUrl;
-        err.resHeaders = resHeaders;
-        reject(err);
     });
 }
 
+async function get(url: string, options?: Omit<reqOptions, 'method'>) {
+    return request(url, { ...options, method: 'get' });
+}
+
+async function post(url: string, options?: Omit<reqOptions, 'method'>) {
+    return request(url, { ...options, method: 'post' });
+}
+
+async function put(url: string, options?: Omit<reqOptions, 'method'>) {
+    return request(url, { ...options, method: 'put' });
+}
+
+async function head(url: string, options?: Omit<reqOptions, 'method'>) {
+    return request(url, { ...options, method: 'head' });
+}
+
 export {
     reqOptions,
     reqSendBufferOptions,
@@ -297,4 +377,8 @@ export {
     reqSendBuffer,
     reqSendStream,
     reqSendMultiPart,
+    get,
+    post,
+    put,
+    head
 };