2020/11/26

Use a specific version of ocaml in debian/ubuntu

I used the latest Debian distribution. When I compiling coccinelle, I encountered the error message unbound module Parmap. The reason is that ocaml version that is too new. It is incompatible and must be returned to version 4.02.3. So I use opam to manage the ocaml version used.


1. Inteall opam (root).

sudo apt-get install opam


2.  Initial opam (none root).

opam init --compiler 4.02.3


3. Add ocaml path to environment $PATH.

eval $(opam config env)


4. Check the version you got.

ocamlc -v


5. Install modules.

opam install parmap

opam install camlp4

  

6. When need to switch installed versions.

opam switch 4.05.0

eval $(opam config env)


7. When need to compile and switch other versions.

opam switch create 4.03.0

eval $(opam config env)



on 沒有留言:
標籤： ,

2020/11/20

讓 uboot envtools 禁止變更重要的變數

uboot envtools 提供很方便的途徑來存取 uboot 環境變數，但是方便的工具卻也帶來很大的風險，如果被惡意使用，變更了重要的 uboot 環境變數，例如 bootcmd，可能會導致無法預期的後果，所以真的有必要禁止使用 uboot envtools 改變這些重要的變數內容。

以下內容是以 uboot 2014.10 為基礎, 更新的版本應該也不會有太大的差異.

檔案 uboot/tools/env/fw_env.c

最主要的寫入 function 是：
    int fw_env_write(char *name, char *value)

要做的事情很單純：
  1. 增加一個檢查要寫入的環境變數名稱的 function, 可以被更改的傳回 0, 不能被更改的傳回非0.
  2. 在 fw_env_wrire 裡面呼叫 1. 加入的 function 進行檢查.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
int fw_env_check_unmodifiable_name(char *name) {
	int i, cnt;
	char *unmodi[] = {
		"bootcmd",
		"baudrate",
		"ethaddr",
		"country",
		"regdomain",
		};
        cnt = sizeof(unmodi)/sizeof(unmodi[0]);
	for (i=0; i<cnt; i++) {
		if (0 == strcmp(unmodi[i], name)) {
			fprintf(stderr, "## Warning: "
						"environment \"%s\" can't be modified.\n", name);
			errno = EINVAL;
			return -EINVAL;
		}
	}
	return 0;
}

/*
 * Set/Clear a single variable in the environment.
 * This is called in sequence to update the environment
 * in RAM without updating the copy in flash after each set
 */
int fw_env_write(char *name, char *value)
{
	int len;
	char *env, *nxt;
	char *oldval = NULL;
	int deleting, creating, overwriting;

	if (fw_env_check_unmodifiable_name(name)) {
		return 0;
	}


on 沒有留言:

2020/11/04

使用 OpenWRT 建構捕捉無線網路封包的設備

OpenWRT wifi basic

OpenWRT 有提供無線網路介面的monitor模式(我猜還是要驅動程式有支援才有用)。

首先修改 /etc/config/wireless 建立一個做為 monitor 的 interface

config wifi-iface wifi_mon0

option device 'wifi0'

option mode 'monitor'


 重新啟用 WiFi 之後，就可以看到這個 interface. 我沒有開啟其他 interface 所以介面名稱被分配為 ath0.


monitor 介面建立完成後, 就可以使用 tcpdump 來捕捉封包, 並寫成 pcap 檔案.

tcpdump -i ath0 -w /tmp/ath0.pcap


用 tcpdump 捕捉特定 MAC 的 802.11 radio 封包

tcpdump -ne -y ieee802_11_radio -i ath0 ether host 00:11:22:33:44:55


最後再設法提取到 wireshark 解讀.



 



on 沒有留言:

2020/06/09

[C] Simple state machine with pthread support 


  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#if 1
#define DPRINTF(format, ...) do { \
	printf(format, ## __VA_ARGS__); \
	} while(0)
#else
#define DPRINTF(format, ...) do {} while(0)
#endif

#define SM_CONTINUE	1
#define SM_STOP		0
#define MAX_THREAD	10

enum STATE {
	ST_NULL=0,
	ST_1,
	ST_2,
	ST_MAX,
};

struct STATE_INFO {
	int threadIndex;
	enum STATE state;
	char wait;
};

struct STATE_MACHINE {
	enum STATE state;
	int (*stFunc) (struct STATE_INFO *sInfo);
};

int st1 (struct STATE_INFO *sInfo);
int st2 (struct STATE_INFO *sInfo);

struct STATE_MACHINE statemachineList[ST_MAX] = {
	{ST_1,		st1},
	{ST_2,		st2},
};

pthread_t tid[MAX_THREAD]={0};

void threadWaitReady(struct STATE_INFO *sInfo) {
	while (sInfo->wait) {
		usleep(100);
	}
}

int statemachineFindIndexByState(enum STATE state)
{
	int i, index=-1;
	int stCount = sizeof(statemachineList)/sizeof(struct STATE_MACHINE);
	
	for(i=0; i<stCount; i++) {
		if (statemachineList[i].state == state) {
			index = i;
			i = stCount;
		}
	}
	return index;
}

void * statemachineMain(void *arg)
{
	struct STATE_INFO sInfo, *ssInfo;
	int stateIndex;
	char resume=SM_CONTINUE;

	pthread_detach(pthread_self());
	memcpy(&sInfo, arg, sizeof(sInfo));
	ssInfo = arg;
	ssInfo->wait = 0;
	DPRINTF("t[%d] [%s] start statemachine with state %d\n", sInfo.threadIndex, __func__, sInfo.state);
	while (resume != SM_STOP) {
		stateIndex = statemachineFindIndexByState(sInfo.state);
		if (-1 == stateIndex) {
			resume = SM_STOP;
		} else {
			if (statemachineList[stateIndex].stFunc)
			{
				resume = statemachineList[stateIndex].stFunc(&sInfo);
			} else {
				resume = SM_STOP;
				DPRINTF("t[%d] [%s] state %d without callback function\n", sInfo.threadIndex, __func__, sInfo.state);
			}
		}
	}
	tid[sInfo.threadIndex] = 0;
	pthread_exit(NULL);
}

int threadFindFree (void)
{
	int i, retval=-1;
	for (i=0; i<MAX_THREAD; i++) {
		if (0 == tid[i]) {
			retval = i;
			break;
		}
	}
	return retval;
}

int main(int argc, char *argv[])
{
	struct STATE_INFO sInfo;
	int i, tIndex;
	
	i=0;
	while(1) {
		bzero(&sInfo, sizeof(sInfo));
		sInfo.threadIndex = threadFindFree();
		if (-1 != sInfo.threadIndex) {
			++i;
			i %= ST_MAX;
			sInfo.state = i;
			sInfo.wait = 1;
			if(pthread_create(&tid[sInfo.threadIndex], NULL, statemachineMain, (void*) &sInfo) != 0 ) {
				tid[sInfo.threadIndex] = 0;
				DPRINTF("t[%d] [%s] Failed to create thread\n", sInfo.threadIndex , __func__);
			} else {
				threadWaitReady(&sInfo);
			}
		}
		usleep(1234567);
	}
}

int st1 (struct STATE_INFO *sInfo)
{
	DPRINTF("t[%d] [%s]\n", sInfo->threadIndex, __func__);
	sInfo->state = ST_2;
	usleep(1000000);
	return SM_CONTINUE;
}

int st2 (struct STATE_INFO *sInfo)
{
	DPRINTF("t[%d] [%s]\n", sInfo->threadIndex, __func__);
	sInfo->state = ST_1;
	usleep(2000000);
	return SM_CONTINUE;
}

on 沒有留言:
標籤：

2020/05/26

Linux shell to access tcp connection.

Open a new connection 
1
exec FILE_DESCRIPTOR<>/dev/PROTOCOL/HOST/PORT
FILE_DESCRIPTOR: 0=stdin, 1=stdout, 2=stderr. So you can use numbers larger than 3.
PROTOCOL: tcp or udp
HOST: Host name or IP address.
PORT: Host listen port.


Send message
1
echo -e "MESSAGE" >&FILE_DESCRIPTOR
MESSAGE: The message which you want to send.
FILE_DESCRIPTOR: File descriptor when creating the connection..


Receive message
1
timeout SECOND cat <&FILE_DESCRIPTOR
SECOND: Wait SECOND seconds and then time out.
FILE_DESCRIPTOR: File descriptor when creating the connection..


Close connection
1
exec FILE_DESCRIPTOR<&-
FILE_DESCRIPTOR: File descriptor when creating the connection..


Example
1
2
3
4
5
6
7
8
9
exec 3<>/dev/tcp/192.168.5.250/1539
sleep 1
echo -e "test" >&3
timeout 5 cat <&3
sleep 1
echo -e "exit" >&3
timeout 5 cat <&3
sleep 1
exec 3<&-
on 沒有留言:
訂閱： 文章 (Atom)