联通在线打印发票流程

Publish: November 22, 2016 Category: 默认分类 No Comments

http://www.10010.com/bj/


充值交费:

    首页 --- 点击‘交费充值’ --- 输入手机号,交费金额选其它(自己填写100) --- 下一步 走充值流程


打印发票:

    首页 --- 话费查询 --- 电子发票查询及开具 --- 实缴发票 --- 点选要开的发票 --- 右侧点“立即开电子发票” --- 输入手机号和邮箱 --- 下一步 确认办理

    收到短信后,刷新本页,该电子发票状态从‘开票中’变为‘可下载’, 点选后,右侧点击下载电子发票(PDF)


SSR 服务器端安装(单用户版)

Publish: November 7, 2016 Category: Shell,C/C++ No Comments

基本库安装

centos:

yum install python-setuptools && easy_install pip
yum install git

ubuntu/debian:

apt-get install python-pip
apt-get install git

获取源代码

git clone -b manyuser https://github.com/breakwa11/shadowsocks.git

执行完毕后此目录会新建一个shadowsocks目录,基本根目录的是多用户版(即数据库版),子目录中的是单用户版

  • 根目录即: ./shadowsocks

  • 子目录即: ./shadowsocks/shadowsocks


服务端配置

添加用户配置文件: /etc/shadowsocks-rss/user-config.json

{
    "server": "0.0.0.0",
    "server_ipv6": "::",
    "server_port": 8388,
    "local_address": "127.0.0.1",
    "local_port": 1080,
    "password": "123qwe",
    "timeout": 120,
    "udp_timeout": 60,
    "method": "aes-256-cfb",
    "protocol": "origin",
    "protocol_param": "",
    "obfs": "http_simple_compatible",
    "obfs_param": "",
    "dns_ipv6": false,
    "connect_verbose_info": 0,
    "redirect": "",
    "fast_open": false
}

启动 (一定要先进入单用户版本)

# cd shadowsocks/shadowsocks
# python server.py -c /etc/shadowsocks-rss/user-config.json


OSX10.12 Sierra 注册机无法运行解决方法

Publish: November 3, 2016 Category: Shell No Comments

    macOS Sierra 使用注册机方法:

    打开注册机目录找到两个文件: patcher, eyePatch

    执行命令:

# patcher 需要破解的程序 eyePatch 需要破解的程序

    例子(以Dash 3.x [SP].app为例):

        1. 找到上述两个文件: 

            右键Dash 3.x [SP].app --- 显示包内容 --- Contents --- MacOS

        2. 打开终端: 

            应用程序 --- 实用工具 --- 终端

        3. 执行注册: 

           将第一步文件夹内的"patcher"拖入"终端"中,

           再将应用程序中需要破解的程序继续拖入"终端"中(终端中的格式不要手动去改动),

           接着,继续将"eyePatch"拖入"终端"中,

           再次将应用程序中需要破解的程序拖入"终端",

           最后"回车"即可完成注册破解。

        4. 第三步的操作以命令的方式显示为: 

           patcher 程序 eyePatch 程序 回车


    针对 CORE KeyGen 使用方法:

        1. 下载 upx.out 程序并解压缩

        2. 打开终端:

            应用程序 --- 实用工具 --- 终端,将解压缩得到的"upx.out"拖入"终端", 之后输入-d, 再空格;

        3. 将 dmg 镜像中的"CORE Keygen.app"拷贝到任意位置,同样,右键CORE Keygen.app---显示包内容---Contents---MacOS,将其中的"CORE Keygen"继续拖入第二步的终端中;

        4. 回车,终端中显示"Unpacked 1 file."表示成功,这时"CORE Keygen.app"已经可以在macOS Sierra下正常打开了;

        5. 以上操作总结命令如下: 

            upx.out -d CORE Keygen 回车;


文章引用:  http://www.sdifenzhou.com/macossierrakeygen.html





正确用DD测试磁盘读写速度

Publish: October 17, 2016 Category: Shell No Comments

以下几种方式测试磁盘读写速度的区别:

# 仅得到写缓存的速度
dd bs=1M count=128 if=/dev/zero of=test

# 当sync做准备开始往磁盘上写数据时,前面的dd已经显示错误的‘写入速度’
dd bs=1M count=128 if=/dev/zero of=test; sync

# 读取128M数据到内存并写入到磁盘上所用时间 【比较符合实际】
dd bs=1M count=128 if=/dev/zero of=test conv=fdatasync

# 每次读1M后就要先把这1M写入磁盘,重复128次,基本上没用到写缓存
dd bs=1M count=128 if=/dev/zero of=test oflag=dsync

建议使用:

dd bs=1M count=128 if=/dev/zero of=test conv=fdatasync

因为这种方式最接近计算机实际操作,所以测出来的数据最有参考价值

例子:

# dd bs=10M count=128 if=/dev/zero of=test conv=fdatasync
128+0 records in
128+0 records out
1342177280 bytes (1.3 GB) copied, 4.60449 s, 291 MB/s

结果为:291MB/s


原则上:

  • 可以通过使用dd if=/dev/zero of=/file 来测试磁盘的纯写入性能。

  • 使用dd if=/file of=/dev/null 来测试磁盘的纯读取性能。

  • 使用dd if=/file1 of=/file2 来测试磁盘的读写性能。


测试硬盘的结果如下

(1)测试纯写入性能

#dd if=/dev/zero of=test bs=1M count=64 conv=fdatasync oflag=direct
64+0 records in
64+0 records out
67108864 bytes (67 MB) copied, 0.0710237 s, 945 MB/s

结果为945 MB/s。


(1)测试纯读取性能

# dd if=./test of=/dev/null bs=1M count=64 iflag=direct
64+0 records in
64+0 records out
67108864 bytes (67 MB) copied, 0.0283407 s, 2.4 GB/s

结果为2.4GB/s。

使用pipe进行进程间通讯

Publish: September 23, 2016 Category: C/C++ No Comments

    使用pipe进行进程间通讯,pipe只能在共同血缘(父子进程)进程中使用。

一、父子进程间通讯:

/*
 * 双向管道流模式: 父子进程互相读写
 * 
 *    --------      ---------------     --------
 *   | 父进程  |    |    UNIX 内核  |    | 子进程  |
 *   |        |    |===============|    |        |
 *   | pfd1[1]|--->|输入  管道I  输出|--->| pfd1[0]|
 *   |        |    |===============|    |        |
 *   | pfd2[0]|<---|输出  管道II 输入|<---| pfd2[1]|
 *   |        |    |               |    |        |
 *    --------      ---------------      --------
 *    
 */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
    int pfd1[2], pfd2[2];
    pid_t pid;
    if (pipe(pfd1) < 0) {
        fprintf(stderr, "pipe fail:%s\n", strerror(errno));
        exit(0);
    }
    if (pipe(pfd2) < 0) {
        fprintf(stderr, "pipe fail:%s\n", strerror(errno));
        exit(0);
    }
    if ((pid = fork()) < 0) {
        fprintf(stderr, "fork fail:%s\n", strerror(errno));
        exit(0);
    }
    if (pid == 0) {
        // ------ 子进程 ------
        close(pfd1[1]);
        close(pfd2[0]);
        char buf[1024] = {0};
        int r = 0;
        while (r = read(pfd1[0], buf, sizeof(buf))) {
            if (r > 0) {
                printf("  [child_%ld]:Read %d:%s", getpid(), r, buf);
                if (strcasecmp(buf, "quit\n") == 0) {
                    r = snprintf(buf, sizeof(buf), "Bye Bye.\n");
                    r = write(pfd2[1], buf, r);
                    printf("  [child_%ld]: %ld:%s", getpid(), r, buf);
                    return 0;
                }
                memset(buf, 0, sizeof(buf));
                r = snprintf(buf, sizeof(buf), "250 OK\n");
                r = write(pfd2[1], buf, r);
                printf("  [child_%ld]:Write %ld:%s", getpid(), r, buf);
                memset(buf, 0, sizeof(buf));
            }
        }
        return 0;
    }
    // ------ 父进程 ------
    char buf[1024] = {0};
    int r = 0;
    close(pfd1[0]);
    close(pfd2[1]);
    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        printf("[parent_%ld]:Read %d:%s", getpid(), strlen(buf), buf);
        r = write(pfd1[1], buf, strlen(buf));
        printf("[parent_%ld]:Write %d bytes, Succ\n", getpid(), r);
        memset(buf, 0, sizeof(buf));
        r = read(pfd2[0], buf, sizeof(buf));
        printf("[parent_%ld]:Read: %d:%s", getpid(), r, buf);
        if (strcasecmp(buf, "Bye Bye.\n") == 0) {
            printf("[parent_%ld]:Read: %d:%s", getpid(), r, buf);
            return 0;
        }
        memset(buf, 0, sizeof(buf));
    }
    return 0;
}


二、连接标准I/O的管道流模式:  子进程使用标准I/O文件描述符进行通讯

    pipe_parent.c:

/*
 * 连接标准I/O的管道流模式: 父子进程互相读写
 * 
 *    --------            -----------------          ---------------
 *   | 父进程 |          |    UNIX 内核    |        | 子进程        |
 *   |        |          |=================|        |               |
 *   | pfd1[1]| -------> |输入  管道I  输出| ------>| 0 <==>pfd1[0] |
 *   |        |          |=================|        |               |
 *   | pfd2[0]| <------- |输出  管道II 输入| <------| 1 <==>pfd2[1] |
 *   |        |          |                 |        |               |
 *    --------            -----------------          ---------------
 *    
 */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
char *(pipe_child[]) = { "./pipe_child", 0};
int main(int argc, char **argv)
{
    int pfd1[2], pfd2[2];
    pid_t pid;
    if (pipe(pfd1) < 0) {
        fprintf(stderr, "pipe fail:%s\n", strerror(errno));
        exit(0);
    }
    if (pipe(pfd2) < 0) {
        fprintf(stderr, "pipe fail:%s\n", strerror(errno));
        exit(0);
    }
    if ((pid = fork()) < 0) {
        fprintf(stderr, "fork fail:%s\n", strerror(errno));
        exit(0);
    }
    if (pid == 0) {
        // ------ 子进程 ------
        if (dup2(pfd1[0], 0) < 0) {
        fprintf(stderr, "child dup2 fail:%s\n", strerror(errno));
        _exit(1);
        }
        if (dup2(pfd2[1], 1) < 0) {
            fprintf(stderr, "child dup2 fail:%s\n", strerror(errno));
            _exit(1);
        }
        close(pfd1[1]);
        close(pfd2[0]);
        int ret = execvp(*pipe_child, pipe_child);
        if (ret < 0) {
            fprintf(stderr, "child execvp:%s fail:%s\n", pipe_child, strerror(errno));
            _exit(1);
        }
        return 0;
    }
    // ------ 父进程 ------
    close(pfd1[0]);
    close(pfd2[1]);
    char buf[1024] = {0};
    int r = 0;
    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        printf("[parent_%ld]:Read %d:%s", getpid(), strlen(buf), buf);
        r = write(pfd1[1], buf, strlen(buf));
        printf("[parent_%ld]:Write %d bytes, Succ\n", getpid(), r);
        memset(buf, 0, sizeof(buf));
        r = read(pfd2[0], buf, sizeof(buf));
        printf("[parent_%ld]:Read: %d:%s", getpid(), r, buf);
        if (strcasecmp(buf, "Bye Bye.\n") == 0) {
            printf("[parent_%ld]:Read: %d:%s", getpid(), r, buf);
            return 0;
        }
        memset(buf, 0, sizeof(buf));
    }
    return 0;
}


    pipe_child.c:

/*
 * 连接标准I/O的管道流模式: 父子进程互相读写
 * 
 *    --------            -----------------          ---------------
 *   | 父进程 |          |    UNIX 内核    |        | 子进程        |
 *   |        |          |=================|        |               |
 *   | pfd1[1]| -------> |输入  管道I  输出| ------>| 0 <==>pfd1[0] |
 *   |        |          |=================|        |               |
 *   | pfd2[0]| <------- |输出  管道II 输入| <------| 1 <==>pfd2[1] |
 *   |        |          |                 |        |               |
 *    --------            -----------------          ---------------
 *    
 */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
    char buf[1024] = {0};
    int r = 0;
    while (r = read(0, buf, sizeof(buf))) {
        if (r > 0) {
            fprintf(stderr, "  [child_%ld]:Read %d:%s", getpid(), r, buf);
            if (strcasecmp(buf, "quit\n") == 0) {
                r = snprintf(buf, sizeof(buf), "Bye Bye.\n");
                r = write(1, buf, r);
                fprintf(stderr, "  [child_%ld]: %ld:%s", getpid(), r, buf);
                return 0;
            }
            memset(buf, 0, sizeof(buf));
            r = snprintf(buf, sizeof(buf), "250 OK\n");
            r = write(1, buf, r);
            fprintf(stderr, "  [child_%ld]:Write %ld:%s", getpid(), r, buf);
            memset(buf, 0, sizeof(buf));
        }
    }
    return 0;
}