apache-nginx-url-rewrite-convert

Apache(.htaccess):

RewriteEngine On
RewriteBase /
RewriteRule ^()$ index.php [NC,L]
Rewritecond %{REQUEST_URI} !(^/?.*..*$) [NC]
RewriteRule (.*)$ $1.php [NC]

nginx:

location / {
root /htdocs/;
index index.php index.html index.htm;
rewrite ^/()$ /index.php last;
rewrite /(.*)$ /$1.php;
}

SQLite 3导入导出成txt或csv操作

平时使用官方提供的sqlite3.exe工具来操作 sqlite的数据库,可以在网上下到。
进入管理：

sqlite3.exe d:test.db //假设数据是　d:test.db
>.databases //显示所有数据库 和 mysql的　show databases;　
>.tables //显示当前数据库的表格　和 mysql 的show tables;　
>.schment tablename; //显示表格结构　和mysql的　SHOW CREATE TABLE tbl_name
>.output c:\1.sql //导出当前数据库的 sql语句　和mysql的 mysqldump
>.dump
>.import c:\1.sql //导入　//mysql 用source

===================
导入
命令: .import

sqlite> .import 文件名 表名

注1: 不要忘了开头的点
注2: 这条语句不能用分号结束. 非SQL不需要分号结束.
注3: 需要查看默认的分隔符separator. 必须一致. 如果不一致可能导致sqlite字段分割错误.
查看分隔符使用命令 .show , 如果不一致可直接修改, 比如:

sqlite>.separator “,”

将分隔符转为逗号.
举例1:
将文件a.txt中的数据导入表 tab_xx. (a.csv中字段以逗号分割)

sqlite> .separator ","
sqlite> .import a.txt tab_xx
sqlite>

导入结束.

导出
实现方式: 将输出重定向至文件.
命令: .output

sqlite> .output a.txt

然后输入sql语句, 查询出要导的数据. 查询后,数据不会显示在屏幕上,而直接写入文件.
结束后,输入

sqlite> .output stdout

将输出重定向至屏幕.
举例2:
将 tab_xx 中的数据导出到文件a.txt

sqlite> .output a.txt
sqlite> select * from tab_xx;
sqlite> .output stdout

导出完毕.

如需导成csv格式，直接将文件a.txt换成a.csv即可

Sqlite数据库导入导出与备份恢复作者：春儿
（1）数据导入
建立了Sqlite数据库后就要建立表输入数据了，多数时候数据量较大，手动输入不可能，必须用导入语句
导入逗号分隔csv格式数据
首先建立一个表，比如test.db中建表test，如果表已经存在，可以利用命令”.schema”查看该表结构，比如
sqlite>.schema test，结果得到test表的结构，因为要导入的数据必须具有相似的结构，所以必须明了目标表的结构。
create table test (id int primary key,value);
比如test表具有下面的数据
1|34
2|99
3|990
4|390

另一个csv文本文件为 test.csv，内容如下：
5,560
6,78
利用“.import”命令可以导入该数据，在导入数据之前，利用“.separator ””命令转换sqlite默认分隔符，比如“.separator ,”这一句就将分隔符改变为逗号，与预导入数据一致才能顺利导入，然后键入下面语句
.import test.csv test
这样表test就多了从csv文件导入的两行记录，sqlite最新版本已经默认使用事件，因此海量数据导入也很轻松高效。
同样的方法可以导入txt文本文件。

（2）数据导出

.out out.txt
select * from test;
.output stdout

以上三个语句将表test的全部内容查询结果创建并导入了文件out.txt，最后一句是使输出重新定位到屏幕，结束文件导出。

（3）备份数据库

.output [filename] 导出到文件中,如果该文件不存在，则自动创建
.dump 导出数据命令
.output stdout 返回输出到屏幕(进行其他操作)

（4）导入（恢复）数据库

sqlite3 test.db < test.sql

这样就将备份数据库导入当前数据库了。

Sqlite conn.php

try {
$dbh = new PDO(‘sqlite:xiaokyun.sqlite’);
$dbh->exec("CREATE TABLE xiaokyun(id integer primary key AUTOINCREMENT,
xiaokyun varchar(233) NOT NULL UNIQUE,
info varchar(233) default ‘xiaokyun’)");
$dbh->exec("INSERT INTO xiaokyun(xiaokyun, info) values(‘http://www.xiaokyun.com/’, ‘xiaokyun’)");
$dbh->beginTransaction();
$sth = $dbh->prepare(‘SELECT * FROM xiaokyun’);
$sth->execute();
$result = $sth->fetchAll();
print_r($result);
$dbh=null;
}
catch (PDOException $e){
echo ‘Connection failed: ‘ . $e->getMessage();
$dbh=null;
}

MySQL conn.php

define(‘DB_NAME’, ”);
define(‘DB_USER’, ”);
define(‘DB_PASSWORD’, ”);
define(‘DB_HOST’, ”);

$link = mysql_connect(DB_HOST,DB_USER,DB_PASSWORD) or die (‘数据库连接失败！</br>错误原因：’.mysql_error());

mysql_query("set names ‘utf8’");

mysql_select_db(DB_NAME,$link) or die(‘数据库选定失败！</br>错误原因：’.mysql_error());

$result = mysql_query($sql) or die(‘数据库查询失败！</br>错误原因：’.mysql_error());

PPTP URL Recorder

经常使用别个共享的梯子的人要注意了，你的隐私去哪儿了？

把HTTP请求的URL全部记录下来，vps上用的~~ 日志记录在 “/var/log/url_record.txt” 程序守护进程方式运行在后台
pptp类型的vpn，每个vpn用户登录的时候，系统会创建一个虚拟网卡pppx， 程序捕获到事件后会自动一个线程针对这个虚拟网卡抓包

Debian/Ubuntu: apt-get install libpcap-dev -y
CentOS:yum install libpcap-devel -y

gcc -o url_recorder url_recorder.c -lpcap -lpthread

需要root权限
./url_recoder

代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <netinet/in.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <arpa/inet.h>
#include <pcap.h>
#include <unistd.h>
#include <time.h>
#include <pthread.h>

#define PROMISC 1
#define SNAPLEN 1600

static char log_file[] = "/var/log/url_record.txt";
static char pidfile[] = "/var/run/url_recorder";
static FILE* log_fp;
static pthread_mutex_t log_mutex;
static char nic_bitmap[20];
static char nic[10];

int log_init()
{
	int ret;
	
	pthread_mutex_init(&log_mutex,NULL);
	log_fp = fopen(log_file,"a+");
	if (log_fp == NULL){
		printf("open log file failedn");
	}
	
	return 0;
}

int logging(char *data,int len)
{
	time_t timet;
	struct tm *p;
	char str_time[100];

	timet = time(NULL);
	p = localtime(&timet);
	
	pthread_mutex_lock(&log_mutex);

	strftime(str_time,sizeof(str_time),"<--%m-%d %H:%M:%S-->  ",p);
	fwrite(str_time,strlen(str_time),1,log_fp);
	fwrite(data,len,1,log_fp);
	fputc('n',log_fp);
	fflush(log_fp);

	pthread_mutex_unlock(&log_mutex);	

	return 0;
}

int create_pidfile()
{
	return 0;
}


int is_http_request(const unsigned char* buf, int len)
{
    if (buf[0] == 'G' && buf[1] == 'E' && buf[2] == 'T'){
        return 1;
    }

    if (buf[0] == 'P' && buf[1] == 'O' && buf[2] == 'S' && buf[3] == 'T'){
        return 2;
    }

    return 0;
}

int http_hdr_len(const unsigned char* buf, int len)
{
    int i = 0;
    int hdr_len = 0;

    for (i = 0; i < len - 3; i++){
        if (buf[i] == 'r' && buf[i + 1] == 'n'
            && buf[i + 2] == 'r' && buf[i + 3] == 'n'){
            hdr_len = i;
            break;
        }
    }

    return hdr_len;

}

int get_url(unsigned char* buf, int *url_len, const unsigned char *pkt_data, int hdr_len)
{
   const  unsigned char* cur;
    int host_len;
    int uri_len;

    memcpy(buf, "http://", 7);
    buf += 7;
    *url_len = 7;

    cur = strstr(pkt_data, "Host:");
    if (cur == NULL)
        return -1;
    cur += 6;
    host_len = field_len(cur, hdr_len - (cur - pkt_data));

    if (host_len && (*url_len +host_len<1200)){
        memcpy(buf, cur, host_len);
        buf += host_len;
	*url_len += host_len;
    }
    else
    {
        return -1;
    }

    cur = pkt_data;
    if (pkt_data[0] == 'G')
        cur += 4;
    else if (pkt_data[0] == 'P'){
        cur += 5;
    }

    uri_len = field_len(cur, hdr_len - (cur - pkt_data));
    uri_len -= 9;

    if((*url_len + uri_len) < 1200){
	memcpy(buf, cur, uri_len);
    	*url_len += uri_len;
    }
    
    return 0;
    
}

int field_len(const unsigned char* buf, int len)
{
    int i = 0;
    int field_len = 0;
    
    for (i = 0; i < len-1; i++){
        if (buf[i] == 'r' && buf[i + 1] == 'n'){
            field_len = i;
            break;
        }
    }

    return field_len;
}

int is_tcp(const unsigned char* buf, int len)
{
    if (len < 54)
        return 0;
	
	//l2proto = Linux cooked capture
    //if (buf[12] != 0x08 || buf[13] != 0x00){
    if (buf[14] != 0x08 || buf[15] != 0x00){
        return 0;
    }
    
    //if (buf[23] != 0x06){//tcp flag
    if (buf[25] != 0x06){//tcp flag
        return 0;
    }

    return 1;
}

void callback(unsigned char *user, const struct pcap_pkthdr *h, const unsigned char *bytes)
{
    int len;
    const unsigned char *buf;
    const unsigned char *cur;
    unsigned char url[1024];
    int url_len = 0;
    char data[1400];
    int is_req;
    int hdr_len;
    int ret;

    buf = bytes;
    len = h->caplen;
    cur = buf;

    if (!is_tcp(buf, len)){
        return;
    }

    //cur += 54;
    //len -= 54;//tcp hdr ip hdr
    cur += 56;
    len += 56;

    is_req = is_http_request(cur, len);
    hdr_len = http_hdr_len(cur, len);

    switch (is_req){
    case 0:
        break;
    case 1:
        ret = get_url(url,&url_len, cur, hdr_len);
        if (ret == 0){
		logging(url,url_len);
	//printf("url_len:%dn",url_len);
        }
        break;
    case 2:
        ret = get_url(url,&url_len, cur, hdr_len);
        if (ret == 0){
		logging(url,url_len);
        }
        //get_data(data, curl, len);
        break;
    default:
        break;
    }
}


void *capture_thread(void* arg)
{

	char dev[10];
	pcap_t *pt;
	char errbuf[PCAP_ERRBUF_SIZE];

	strcpy(dev,(char*)arg);
    	dev[9] = 0;

	
	pt = pcap_open_live(dev, SNAPLEN, PROMISC, -1, errbuf);
    	if (pt == NULL){
        	printf("open dev failedn");
        	return;
    	}

	pcap_loop(pt, -1, callback,NULL);
//	pthread_detach(pthread_self());
	printf("capture thread createn");

}

int start_capture(char *dev)
{

	char dev_vpath[30] = "/sys/class/net/";
	pthread_t thread;
	pthread_attr_t attr;

	strcpy(nic,dev);
	sleep(1);
	strcat(dev_vpath,nic);
	if(access(dev_vpath,0) == 0){
		int ret;
		pthread_attr_init(&attr);
		pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
		pthread_create(&thread,&attr,capture_thread,nic);
		pthread_attr_destroy(&attr);
	}

	return 0;	
}


void parseBinaryNetLinkMessage(struct nlmsghdr *nlh)
{
	int len = nlh->nlmsg_len - sizeof(*nlh);
	struct ifinfomsg *ifi;

	if(sizeof(*ifi) > (size_t)len){
		printf("Got a short messagen");
		return ;
	}

	ifi = (struct  ifinfomsg*)NLMSG_DATA(nlh);
	if((ifi->ifi_flags & IFF_LOOPBACK) != 0){
		return ;
	}

	struct rtattr *rta = (struct rtattr*)
		((char*)ifi + NLMSG_ALIGN(sizeof(*ifi)));
	len = NLMSG_PAYLOAD(nlh,sizeof(*ifi));

	while(RTA_OK(rta,len)){
		switch(rta->rta_type){
			case IFLA_IFNAME:
			{
				char ifname[IFNAMSIZ];
				int  up;
				char id;
				snprintf(ifname,sizeof(ifname),"%s",
					(char*)RTA_DATA(rta));
				up = (ifi->ifi_flags & IFF_RUNNING)? 1 : 0;
				if (up && ((ifname[0] == 'p')&&(ifname[1] == 'p')&&
					(ifname[2] == 'p'))){
					printf("msg from:%s",ifname);
					sscanf(ifname+3,"%d",(int*)&id);
					if(nic_bitmap[id])
						break;
					start_capture(ifname);
					nic_bitmap[id] = 1;	
					printf("%s  %dn",ifname,up);
				} 
				if (!up && ((ifname[0] == 'p')&&(ifname[1] == 'p')&&
                                        (ifname[2] == 'p'))){
					sscanf(ifname+3,"%d",(int*)&id);
					nic_bitmap[id] = 0;
					printf("%s %dn",ifname,up);
				}
			}
		}

		rta = RTA_NEXT(rta,len);
	}

}


int main(int argc,char** argv)
{

	struct sockaddr_nl addr;
	struct nlmsghdr *nlh;
	char buffer[4096];
	int sock,len;


	daemon(0,0);
	create_pidfile();
	log_init();

	
	if((sock = socket(AF_NETLINK,SOCK_RAW,NETLINK_ROUTE)) == -1){
		printf("open NETLINK_ROUTE socket failedn");
		goto exit;
	}

	memset(&addr,0,sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = RTMGRP_LINK |RTMGRP_IPV4_IFADDR;
	
	if(bind(sock,(struct sockaddr*)&addr,sizeof(addr)) == -1){
		printf("bind failedn");
		goto exit;
	}

	while((len = recv(sock,buffer,4096,0)) > 0){
		nlh = (struct nlmsghdr*)buffer;
		while((NLMSG_OK(nlh,len)) && (nlh->nlmsg_type != NLMSG_DONE)){
			if(nlh->nlmsg_type == RTM_NEWLINK){
				parseBinaryNetLinkMessage(nlh);
			}
			nlh = NLMSG_NEXT(nlh,len);
		}
	}

	close(sock);
	
exit:
		exit(0);
}