PHPor 的Blog – 第75页

<?php
$socket  = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_set_option($socket, SOL_SOCKET, SO_REUSEPORT, 1);
socket_bind($socket, "127.0.0.1", 2345);
socket_listen($socket);
while($s = socket_accept($socket)) {
    $str = socket_read($s, 2048, PHP_NORMAL_READ);
    socket_write($s, posix_getpid().":".$str);
    socket_close($s);
}

<?php

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);

socket_set_option($socket, SOL_SOCKET, SO_REUSEPORT, 1);

socket_bind($socket, "127.0.0.1", 2345);

socket_listen($socket);

while($s = socket_accept($socket)) {

$str = socket_read($s, 2048, PHP_NORMAL_READ);

socket_write($s, posix_getpid().":".$str);

socket_close($s);

}

注意：

centos7上如果是yum安装的php，则posix模块的安装方式是： yum install -y php-process (这个名字不叫posix）
启动之后，如果用yum安装的nc来测试，会出现连接被refused的情况，这是因为centos7上的nc默认用的是tcp6（socket_create时使用AF_INET6），一个服务确定的是连接的3要素：协议、IP、端口；切记，tcp和tcp6是两种不同的协议；解决办法：添加 -4选项，即： nc -4 localhost 2345

执行:

php server.php &

既然设置了SO_REUSEPORT，则应该可以再启动一个吧？结果，同时启动两个，则两个进程都被stop了

再看：去掉 ‘&’ 来执行 php server.php ，不放打开多个terminal，我这里打开了两个，发现两个进程都没有再停止了

再打开一个terminal，执行：

while :; do echo “hello”|nc -4 localhost 2345;done

输出里面混杂出现两个进程的pid，证明：两个进程在同时提供服务了;

注意： 即使是多个进程在提供服务，netstat中看到的却只有一个进程在listen

（mac下测试相同脚本，结果是： netstat中可以看到多个进程在listen，但是实际测试却只有一个进程在提供服务，反正我也不同mac来提供线上服务，这里就不研究mac了)

问题：为什么我这个脚本不能推到后台执行？？？？？？？？

strace 跟踪发现，可能和标准输出有关系（这个应该也是centos7和前面版本的差异），把标准输出重定向走：

php server.php >/dev/null &

这样就不会停止了，之于标准错误、标准输入是否会有其他的影响，这个这里就不再研究了

总结：

SO_REUSEPORT 真心不错

参考资料：

http://www.blogjava.net/yongboy/archive/2015/02/04/422732.html

https://my.oschina.net/miffa/blog/390931

Git 安装

yum安装

$ yum install git

1	$ yum install git

源码安装：

安装依赖：

yum install expat-devel

1	yum install expat-devel

yum install zlib-devel perl-ExtUtils-MakeMaker asciidoc xmlto openssl-devel

1	yum install zlib-devel perl-ExtUtils-MakeMaker asciidoc xmlto openssl-devel

获取git源码：

git clone https://github.com/git/git.git

1	git clone https://github.com/git/git.git

安装：

cd git

cd git

make

make

参考：

http://git-scm.com/download/linux

http://www.tuicool.com/articles/eYZFFn

git-svn: http://chirking.iteye.com/blog/888651

mysql query cache

查看配置：

查看使用情况：

Qcache_free_blocks: 表示查询缓存中目前还有多少剩余的blocks，如果该值显示较大，则说明查询缓存中的内存碎片过多了，可能在一定的时间进行整理

Qcache_free_memory: 查询缓存的内存大小，通过这个参数可以很清晰的知道当前系统的查询内存是否够用，是多了，还是不够用，DBA可以根据实际情况做出调整

Qcache_hits：命中多少

Qcache_inserts：写入多少

Qcache_lowmem_prunes：空间不够，挤出多少（？）

Qcache_not_cached：有多少查询因不符合条件而没有被写入cache （如：结果集太大、sql条件中使用了函数、select 1等等）

Qcache_queries_in_cache：当前缓存了多少查询

Qcache_total_blocks: 当前缓存的block数量

参考：

http://www.111cn.net/database/mysql/44889.htm

http://www.jb51.net/article/58537.htm

ssl证书

参考： https://www.myssl.cn/products/

使用chrome浏览器测试：（更新：好像现在都不显示为绿色了）

访问 github.com ，地址栏显示锁，也显示公司名称,这个属于EV型的SSL证书；非EV型的都不显示公司名称，尽管是OV的也不显示

2. 访问 https://www.beebank.com/ 地址栏显示锁，不显示公司名称，绿色说明页面中没有引用非https的资源

3. 访问 https://login.sina.com.cn/ 下面是已登录状态，没有锁，也不显示公司名称，(说明页面中包含了非https的资源）

未登录状态: 显示锁，不显示公司名称（奇怪不？）

https证书有DV，EV

DV 免费SSL证书(DV KuaiSSL)属于 Domain Validation SSL 或 DV SSL。是 WoSign 基础级 (Class 1) SSL证书产品，只验证域名所有权， 10分钟颁发，保证了网站的机密信息从用户浏览器到服务器之间的传输是高强度加密传输的，是不会被非法窃取和非法篡改的。

从 SSL 证书的诞生史可以看出：标准型 SSL 证书就是 Organization Validation SSL(OV SSL) ， DV SSL 证书是由于市场恶性竞争而形成的怪胎产品，已经严重伤害了用户对电子商务的在线信任 ( 有安全锁都不可信! ) 。

为了解决 DV SSL 被欺诈网站滥用的问题， Comodo 牵头全球各大证书颁发机构和各大主流浏览器厂商成立了一个 CA/浏览器论坛，推出了一个新的 SSL 证书产品来增强电子商务用户的在线信任和保证在线交易的安全，这就是 Extended Validation SSL Certificate, 简称为： EV SSL 证书。 EV SSL 证书采用全球统一严格验证身份标准来颁发 SSL 证书，不仅能像其他 OV SSL 证书一样能高强度加密在线用户的机密交易信息，而且还会非常显著地 ( 浏览器地址栏为绿色 ) 向在线用户表明他们 / 她们确实是正在与一个经过严格身份验证的网站进行在线交易，而不是一个假冒网站。 EV SSL 让浏览器地址栏变成绿色，绿色安全通道，增强在线信任，打造诚信网络，促成更多在线销售!

所以，推荐所有电子商务网站都部署 OV SSL 证书或 EV SSL 证书，特别推荐 EV SSL ，绿色地址栏，让用户更加信任您的网站，从而获得更多在线订单。

赛门铁克的EV证书还附带有每日网站而已软件扫描服务

难道EV类型不提供通配符证书？

关于单域名ssl证书需要注意：

1、当您位 www 前缀的域名申请证书的时候，默认是可以保护不带 www 的主域名，例如您位 www.sslzhengshu.com 申请证书，则 sslzhengshu.com 也默认会被保护；

2、当您位其他前缀的子域名申请证书时，则只能保护当前子域名不能保护不带前缀的主域名。

参考： https://www.sslzhengshu.com/article/post-35.html

一张图读懂https加密协议

https是一种加密传输协议，网站使用https后可以避免敏感信息被第三方获取。所以我们经常看见很多银行网站或电子邮箱等等安全级别较高的服务都会采用https协议，具体表现为，https开头、显示绿色安全锁、某些浏览器地址栏变成绿色。那么具体https是怎么工作的呢?一张图读懂https加密协议。

https加密协议简介

https其实是有两部分组成：http + SSL / TLS，也就是在http上又加了一层处理加密信息的模块。服务端和客户端的信息传输都会通过TLS进行加密，所以传输的数据都是加密后的数据。具体是如何进行加密，解密，验证的，且看下图。

1. 客户端发起https请求

客户端发起https请求就是指用户在浏览器里输入一个https网址，然后连接到server的443端口。

2. 服务器端的配置

采用https协议的服务器必须要有一套SSL数字证书，需要向CA组织(如WoSign沃通CA)申请。这套SSL证书其实就是一对公钥和私钥。如果对公钥和私钥不太理解，可以想象成一把钥匙和一个锁头，只是全世界只有你一个人有这把钥匙，你可以把锁头给别人，别人可以用这个锁把重要的东西锁起来，然后发给你，因为只有你一个人有这把钥匙，所以只有你才能看到被这把锁锁起来的东西。SSL证书是网站实现https加密协议的先决条件，可以向CA机构申请免费SSL证书，也可以付费购买高级别的SSL证书。目前沃通CA提供3年期免费SSL证书申请http://freessl.wosign.com。

3. 传送证书

这个证书其实就是公钥，只是包含了很多信息，如证书的颁发机构，证书过期时间等等。

4. 客户端解析证书

这部分工作是有客户端的TLS来完成的，首先会验证公钥是否有效，比如颁发机构，过期时间等等，如果发现异常，则会弹出一个警告框，提示证书存在问题。如果证书没有问题，那么就生成一个随机值。然后用证书对该随机值进行加密。就好像上面说的，把随机值用锁头锁起来，这样除非有钥匙，不然看不到被锁住的内容。

5. 传送加密信息

这部分传送的是用SSL证书加密后的随机值，目的就是让服务端得到这个随机值，以后客户端和服务端的通信就可以通过这个随机值来进行加密解密了。

6. 服务段解密信息

服务端用私钥解密后，得到了客户端传过来的随机值(私钥)，然后把内容通过该值进行对称加密。所谓对称加密就是，将信息和私钥通过某种算法混合在一起，这样除非知道私钥，不然无法获取内容，而正好客户端和服务端都知道这个私钥，所以只要加密算法够彪悍，私钥够复杂，数据就够安全。

7. 传输加密后的信息

这部分信息是服务段用私钥加密后的信息，可以在客户端被还原。

8. 客户端解密信息

客户端用之前生成的私钥解密服务段传过来的信息，于是获取了解密后的内容。整个过程第三方即使监听到了数据，也束手无策。

来自： http://freessl.wosign.com/https-xy.html （文章不错，也顺便给人家做个广告吧）

残酷的OOM

问题： 30个虚拟机一下子全死光光了，而且/var/log/message 中没有任何遗言；莫不是被攻击了？

不要瞎猜，查一下吧

# dmesg |grep "Out of"
Out of memory: Kill process 1732 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1290 (portreserve) score 1 or sacrifice child
Out of memory: Kill process 1297 (rsyslogd) score 1 or sacrifice child
Out of memory: Kill process 1336 (dbus-daemon) score 1 or sacrifice child
Out of memory: Kill process 1350 (modem-manager) score 1 or sacrifice child
Out of memory: Kill process 28704 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 31695 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1040 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 21474 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1371 (hald) score 1 or sacrifice child
Out of memory: Kill process 1407 (hald-addon-rfki) score 1 or sacrifice child
Out of memory: Kill process 1431 (hald-addon-inpu) score 1 or sacrifice child
Out of memory: Kill process 1435 (hald-addon-acpi) score 1 or sacrifice child
Out of memory: Kill process 1528 (mysqld_safe) score 1 or sacrifice child
Out of memory: Kill process 23326 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1779 (crond) score 1 or sacrifice child
Out of memory: Kill process 28153 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1845 (login) score 1 or sacrifice child
Out of memory: Kill process 28247 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1847 (mingetty) score 1 or sacrifice child
Out of memory: Kill process 1849 (mingetty) score 1 or sacrifice child
Out of memory: Kill process 1851 (mingetty) score 1 or sacrifice child
Out of memory: Kill process 28367 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 28431 (mysqld) score 22 or sacrifice child
Out of memory: Kill process 1853 (mingetty) score 1 or sacrifice child
Out of memory: Kill process 1855 (mingetty) score 1 or sacrifice child
Out of memory: Kill process 2060 (VBoxXPCOMIPCD) score 1 or sacrifice child
Out of memory: Kill process 2066 (VBoxSVC) score 1 or sacrifice child

# dmesg |grep "Out of"

Out of memory: Kill process 1732 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1290 (portreserve) score 1 or sacrifice child

Out of memory: Kill process 1297 (rsyslogd) score 1 or sacrifice child

Out of memory: Kill process 1336 (dbus-daemon) score 1 or sacrifice child

Out of memory: Kill process 1350 (modem-manager) score 1 or sacrifice child

Out of memory: Kill process 28704 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 31695 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1040 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 21474 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1371 (hald) score 1 or sacrifice child

Out of memory: Kill process 1407 (hald-addon-rfki) score 1 or sacrifice child

Out of memory: Kill process 1431 (hald-addon-inpu) score 1 or sacrifice child

Out of memory: Kill process 1435 (hald-addon-acpi) score 1 or sacrifice child

Out of memory: Kill process 1528 (mysqld_safe) score 1 or sacrifice child

Out of memory: Kill process 23326 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1779 (crond) score 1 or sacrifice child

Out of memory: Kill process 28153 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1845 (login) score 1 or sacrifice child

Out of memory: Kill process 28247 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1847 (mingetty) score 1 or sacrifice child

Out of memory: Kill process 1849 (mingetty) score 1 or sacrifice child

Out of memory: Kill process 1851 (mingetty) score 1 or sacrifice child

Out of memory: Kill process 28367 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 28431 (mysqld) score 22 or sacrifice child

Out of memory: Kill process 1853 (mingetty) score 1 or sacrifice child

Out of memory: Kill process 1855 (mingetty) score 1 or sacrifice child

Out of memory: Kill process 2060 (VBoxXPCOMIPCD) score 1 or sacrifice child

Out of memory: Kill process 2066 (VBoxSVC) score 1 or sacrifice child

因为rsyslogd死的比较早，所以 /var/log/message 没有任何有用的信息
虽然mysqld被杀了很多次，但是依然存在，是因为mysqld_safe 没有被杀，当mysqld死掉时，mysqld_safe 就会再起一个mysqld。什么？mysqld_safe 也在死亡名单中出现了？确实，后来发现了，手动重启了，且看mysqld_safe 之后的多次mysqld被杀就行了
终于VBoxSVC 被杀,所有虚拟机就全部死光光了

如果把sshd杀死了，岂不是很悲催？参看openssh-server 的源码： https://github.com/openssh/openssh-portable/blob/8408218c1ca88cb17d15278174a24a94a6f65fe1/openbsd-compat/port-linux.c ，其中有如下逻辑：（就是说，这家伙有自我保护功能，通过调整/proc/self/oom_score_adj 或 /proc/self/oom_adj实现，其中的设置保证该进程不会被oom掉，其他进程也可以这么效仿）

#ifdef LINUX_OOM_ADJUST
/*
 * The magic "don't kill me" values, old and new, as documented in eg:
 * http://lxr.linux.no/#linux+v2.6.32/Documentation/filesystems/proc.txt
 * http://lxr.linux.no/#linux+v2.6.36/Documentation/filesystems/proc.txt
 */

static int oom_adj_save = INT_MIN;
static char *oom_adj_path = NULL;
struct {
	char *path;
	int value;
} oom_adjust[] = {
	{"/proc/self/oom_score_adj", -1000},	/* kernels >= 2.6.36 */
	{"/proc/self/oom_adj", -17},		/* kernels <= 2.6.35 */
	{NULL, 0},
};

/*
 * Tell the kernel's out-of-memory killer to avoid sshd.
 * Returns the previous oom_adj value or zero.
 */
void
oom_adjust_setup(void)
{
	int i, value;
	FILE *fp;

	debug3("%s", __func__);
	 for (i = 0; oom_adjust[i].path != NULL; i++) {
		oom_adj_path = oom_adjust[i].path;
		value = oom_adjust[i].value;
		if ((fp = fopen(oom_adj_path, "r+")) != NULL) {
			if (fscanf(fp, "%d", &oom_adj_save) != 1)
				verbose("error reading %s: %s", oom_adj_path,
				    strerror(errno));
			else {
				rewind(fp);
				if (fprintf(fp, "%d\n", value) <= 0)
					verbose("error writing %s: %s",
					   oom_adj_path, strerror(errno));
				else
					debug("Set %s from %d to %d",
					   oom_adj_path, oom_adj_save, value);
			}
			fclose(fp);
			return;
		}
	}
	oom_adj_path = NULL;
}

/* Restore the saved OOM adjustment */
void
oom_adjust_restore(void)
{
	FILE *fp;

	debug3("%s", __func__);
	if (oom_adj_save == INT_MIN || oom_adj_path == NULL ||
	    (fp = fopen(oom_adj_path, "w")) == NULL)
		return;

	if (fprintf(fp, "%d\n", oom_adj_save) <= 0)
		verbose("error writing %s: %s", oom_adj_path, strerror(errno));
	else
		debug("Set %s to %d", oom_adj_path, oom_adj_save);

	fclose(fp);
	return;
}
#endif /* LINUX_OOM_ADJUST */

#ifdef LINUX_OOM_ADJUST

* The magic "don't kill me" values, old and new, as documented in eg:

* http://lxr.linux.no/#linux+v2.6.32/Documentation/filesystems/proc.txt

* http://lxr.linux.no/#linux+v2.6.36/Documentation/filesystems/proc.txt

static int oom_adj_save = INT_MIN;

static char *oom_adj_path = NULL;

struct {

char *path;

int value;

} oom_adjust[] = {

{"/proc/self/oom_score_adj", -1000}, /* kernels >= 2.6.36 */

{"/proc/self/oom_adj", -17}, /* kernels <= 2.6.35 */

{NULL, 0},

};

* Tell the kernel's out-of-memory killer to avoid sshd.

* Returns the previous oom_adj value or zero.

void

oom_adjust_setup(void)

{

int i, value;

FILE *fp;

debug3("%s", __func__);

for (i = 0; oom_adjust[i].path != NULL; i++) {

oom_adj_path = oom_adjust[i].path;

value = oom_adjust[i].value;

if ((fp = fopen(oom_adj_path, "r+")) != NULL) {

if (fscanf(fp, "%d", &oom_adj_save) != 1)

verbose("error reading %s: %s", oom_adj_path,

strerror(errno));

else {

rewind(fp);

if (fprintf(fp, "%d\n", value) <= 0)

verbose("error writing %s: %s",

oom_adj_path, strerror(errno));

else

debug("Set %s from %d to %d",

oom_adj_path, oom_adj_save, value);

}

fclose(fp);

return;

}

oom_adj_path = NULL;

}

/* Restore the saved OOM adjustment */

void

oom_adjust_restore(void)

{

FILE *fp;

debug3("%s", __func__);

if (oom_adj_save == INT_MIN || oom_adj_path == NULL ||

(fp = fopen(oom_adj_path, "w")) == NULL)

return;

if (fprintf(fp, "%d\n", oom_adj_save) <= 0)

verbose("error writing %s: %s", oom_adj_path, strerror(errno));

else

debug("Set %s to %d", oom_adj_path, oom_adj_save);

fclose(fp);

return;

}

#endif /* LINUX_OOM_ADJUST */

参考资料： https://www.kernel.org/doc/Documentation/filesystems/proc.txt

Golang call C

题记：是否输出居然和是否和行尾换行有关系

代码：

package main

/*
#include <stdio.h>
#include <stdlib.h>
void myprint(char* s) {
        printf("%s", s);
}
*/
import "C"

import "unsafe"

func main() {
        cs := C.CString("Hello world\n") //把这里的 \n 去掉试试，居然没有输出了
        C.myprint(cs)
        C.free(unsafe.Pointer(cs))
}

package main

#include <stdio.h>

#include <stdlib.h>

void myprint(char* s) {

printf("%s", s);

}

import "C"

import "unsafe"

func main() {

cs := C.CString("Hello world\n") //把这里的 \n 去掉试试，居然没有输出了

C.myprint(cs)

C.free(unsafe.Pointer(cs))

}

why? …

因为printf是行缓冲的，不看到换行就不输出，可以在printf后面刷新标准输出：

fflush(stdout);

1	fflush(stdout);

另，在C的printf后面使用Go的fmt.Println(“^_^”)来输出一些东西，是不是就可以把C要打印的东西给输出来了呢?

代码如下：

package main

/*
#include <stdio.h>
#include <stdlib.h>
void myprint(char* s) {
        printf("%s", s);
}
*/
import "C"

import "unsafe"
import "fmt"

func main() {
        cs := C.CString("Hello world")
        C.myprint(cs)
        C.free(unsafe.Pointer(cs))
        fmt.Println("\nEnd\n")
}

package main

#include <stdio.h>

#include <stdlib.h>

void myprint(char* s) {

printf("%s", s);

}

import "C"

import "unsafe"

import "fmt"

func main() {

cs := C.CString("Hello world")

C.myprint(cs)

C.free(unsafe.Pointer(cs))

fmt.Println("\nEnd\n")

}

结果发现，End 输出了，Hello world还是没输出。

原因：C的输出buffer和Go的不是一个

思考：

亲，你见过用C写的一个Hello world程序是必须有换行的吗？如下：

呃，这个确实没问题，why? C在退出的时候刷新输出缓冲了呗

说明：

To access a symbol originating from the C side, use the package name C. That is, if you want to call the C function printf() from Go code, you write C.printf(). Since variable argument methods like printf aren’t supported yet (issue 975)

翻译：如果你想调用C中的printf，那就是 C.printf(). 但是，向pringf这种可变参数个数的函数穿残还没有被支持，所以还不能直接写C.printf(). 只好自己包一下了