void main()
{
char guid[37];
random_uuid(guid);
printf("guid = %s\n", guid);
random_uuid(guid);
printf("guid = %s\n", guid);
random_uuid(guid);
printf("guid = %s\n", guid);
random_uuid(guid);
printf("guid = %s\n", guid);
}
int main(int argc, char **argv)
{
char oneline[100], filename[MAX_PART_ENTRY][36];
gpt_header pri_header, sec_header;
char gpt_header_pad[GPT_HEADER_SIZE - sizeof(gpt_header)] = {0};
legacy_mbr leg_mbr;
gpt_entry *entry;
unsigned long long start[MAX_PART_ENTRY + 1], end[MAX_PART_ENTRY + 1], dev_sz;
unsigned int i, j, num;
char *output = NULL;
int ret;
cmdname = argv[0];
while (--argc > 0 && **++argv == '-') {
while (*++*argv) {
switch (**argv) {
case 's':
show_content = 1;
break;
case 'o':
if (--argc <= 0)
usage();
output = *++argv;
goto NXTARG;
default:
usage();
}
}
NXTARG:
;
}
if (output) {
num = strlen(output);
if (output[num - 1] == SEPERATOR)
output[num - 1] = 0;
ret = access(output, F_OK);
if (ret) {
#ifndef __MINGW32__
ret = mkdir(output, S_IRWXU | S_IRWXG | S_IROTH);
#else
ret = mkdir(output);
#endif
if (ret)
perror("mkdir fail");
}
}
if (argc != 2) {
usage();
exit(EXIT_FAILURE);
}
if (sscanf(argv[1], "0%*[xX]%100s", oneline) == 1)
dev_sz = strtoull(oneline, 0, 16);
else
dev_sz = strtoull(argv[1], 0, 10);
desp = fopen(*argv, "r");
if (!desp) {
fprintf(stderr, "Can't open %s: %s\n", *argv, strerror(errno));
exit(EXIT_FAILURE);
}
num = 0;
while (fgets(oneline, sizeof(oneline), desp) != NULL) {
switch (sscanf(oneline, "%s\t"OUTPUT"\t"OUTPUT"\n",
filename[num], &start[num], &end[num])) {
case 2:
end[num] = start[num];
break;
case 3:
end[num] -= SECTOR_SIZE;
break;
default:
fprintf(stderr, "desp file err\n");
fclose(desp);
exit(EXIT_FAILURE);
}
if (strlen(filename[num]) > MAX_NAME_SZ) {
fprintf(stderr, "The %dth entry name %s exceed max size of %x\n",
num, filename[num], MAX_NAME_SZ);
fclose(desp);
exit(EXIT_FAILURE);
}
num++;
}
fclose(desp);
if (num == 0)
return 0;
start[num] = dev_sz;
end[num] = dev_sz;
if (end[num - 1] > dev_sz) {
fprintf(stderr, "The last entry end 0x"OUTPUT"exceed device size 0x"OUTPUT"\n",
end[num - 1], dev_sz);
exit(EXIT_FAILURE);
}
reformat_part_size(start, end, num);
entry = malloc(sizeof(gpt_entry) * ENTRY_NUM);
if (!entry) {
fprintf(stderr, "malloc fail\n");
exit(EXIT_FAILURE);
}
if (output) {
sprintf(mbrfile1, "%s%c%s_"OUTPUT_D, output, SEPERATOR,
DEFAULT_MBR_NAME1, dev_sz);
sprintf(mbrfile2, "%s%c%s_"OUTPUT_D, output, SEPERATOR,
DEFAULT_MBR_NAME2, dev_sz);
} else {
sprintf(mbrfile1, "%s_"OUTPUT_D, DEFAULT_MBR_NAME1, dev_sz);
sprintf(mbrfile2, "%s_"OUTPUT_D, DEFAULT_MBR_NAME2, dev_sz);
}
memset(entry, 0, sizeof(gpt_entry) * ENTRY_NUM);
for (i = 0; i < num; i++) {
memcpy(&entry[i].partition_type_guid, &PARTITION_BASIC_DATA_GUID,
sizeof(efi_guid_t));
random_uuid((unsigned char *)&entry[i].unique_partition_guid);
memcpy(&entry[i].starting_lba, &start[i], 8);
memcpy(&entry[i].ending_lba, &end[i], 8);
for (j = 0; j < strlen(filename[i]); j++)
entry[i].partition_name[j] = filename[i][j];
}
dev_sz /= SECTOR_SIZE;
memset(&pri_header, 0, sizeof(pri_header));
pri_header.signature = cpu_to_le64(GPT_HEADER_SIGNATURE);
pri_header.revision = cpu_to_le32(GPT_HEADER_REVISION_V1);
pri_header.header_size = cpu_to_le32(HEADER_SIZE);
pri_header.my_lba = cpu_to_le64(1);
pri_header.alternate_lba = cpu_to_le64(dev_sz - 1);
pri_header.first_usable_lba = cpu_to_le64(FIRST_USABLE_LBA);
pri_header.last_usable_lba = cpu_to_le64(dev_sz - FIRST_USABLE_LBA);
random_uuid((unsigned char *)&pri_header.disk_guid);
pri_header.partition_entry_lba = cpu_to_le64(2);
pri_header.num_partition_entries = cpu_to_le32(ENTRY_NUM);
pri_header.sizeof_partition_entry = cpu_to_le32(GPT_SIZE);
pri_header.partition_entry_array_crc32 = cpu_to_le32(
crc32(0, (const unsigned char *)entry, sizeof(gpt_entry) * MAX_PART_ENTRY)
);
pri_header.header_crc32 = cpu_to_le32(
crc32(0, (const unsigned char *)&pri_header, HEADER_SIZE)
);
memcpy(&sec_header, &pri_header, sizeof(pri_header));
memset(&sec_header.header_crc32, 0, 4);
sec_header.my_lba = cpu_to_le64(dev_sz - 1);
sec_header.alternate_lba = 0;
sec_header.alternate_lba = cpu_to_le64(1);
sec_header.header_crc32 = cpu_to_le32(
crc32(0, (const unsigned char *)&sec_header, HEADER_SIZE)
);
memset(&leg_mbr, 0, sizeof(leg_mbr));
leg_mbr.partition_record[0].sector = 1;
leg_mbr.partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT;
leg_mbr.partition_record[0].end_head = 0xfe;
leg_mbr.partition_record[0].end_sector = 0xff;
leg_mbr.partition_record[0].end_cyl = 0xff;
leg_mbr.partition_record[0].start_sect = cpu_to_le32(1);
leg_mbr.partition_record[0].nr_sects = cpu_to_le32(dev_sz);
leg_mbr.signature = cpu_to_le16(MSDOS_MBR_SIGNATURE);
mbr = fopen(mbrfile1, "wb");
if (!mbr) {
fprintf(stderr, "Can't create %s: %s\n", mbrfile1, strerror(errno));
exit(EXIT_FAILURE);
}
fwrite(&leg_mbr, 1, sizeof(leg_mbr), mbr);
fwrite(&pri_header, 1, sizeof(pri_header), mbr);
fwrite(gpt_header_pad, 1, sizeof(gpt_header_pad), mbr);
fwrite(entry, 1, sizeof(gpt_entry) * ENTRY_NUM, mbr);
fclose(mbr);
mbr = fopen(mbrfile2, "wb");
if (!mbr) {
fprintf(stderr, "Can't create %s: %s\n", mbrfile2, strerror(errno));
exit(EXIT_FAILURE);
}
fwrite(entry, 1, sizeof(gpt_entry) * ENTRY_NUM, mbr);
fwrite(&sec_header, 1, sizeof(sec_header), mbr);
fwrite(gpt_header_pad, 1, sizeof(gpt_header_pad), mbr);
fclose(mbr);
printf("GPT create sucessfull!!!\n"
"Please write the primary mbr first from offset 0 to mmc device offset 0 with the size of 0x22\n"
"And write the second mbr to mmc device offset 0x"OUTPUT" with the size of 0x21\n",
dev_sz - FIRST_USABLE_LBA + 1);
return 0;
}
static void init_loop_cb(struct uloop_timeout *timeout)
{
uint32_t id;
// replace *d
char key_iv[32] = {0};
char repeater_pubkey[] = "-----BEGIN PUBLIC KEY-----\n"\
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyUF9+Td53E0lEqP8eRyM\n"\
"DoREPIety4BJscApuPwcGxiVA+75mYw8AFKlTaWlLL7w/qyuxnOiNm6TTFCxJGI1\n"\
"C9GnABm8myC5hnDSC6qE+E1Al6wZgyI4rkC+Qr7GFI9B8r9bM+RdKyMxD9JuXUcx\n"\
"+rx/TPnJttUfAkCloYStd5LiCel6c/bfWiR5hyxLjXC5Cz5cdpzXwvyvgEBvZHxX\n"\
"A5jqPVfWcJ3P3s88ogPxx52iM4dzLtzWB6BOmZA/3SbvZle2Efy7mVAl/9gkwvgf\n"\
"Dm/TSnMbnUBim3H5CIlECsvs2RuvI5og0S3oEO4B8TQQjujSqbA6h+EcZc9Djmh2\n"\
"vQIDAQAB\n"\
"-----END PUBLIC KEY-----\n";
unsigned char *encrypted=malloc(MAX_ALLOC_LEN);
unsigned char *base64=malloc(MAX_ALLOC_LEN);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or RSA_PKCS1_PADDING/OAEP may fail */
random_uuid(repeater_key);
random_uuid(repeater_iv);
memcpy(key_iv, repeater_key, 16);
memcpy(key_iv+16, repeater_iv, 16);
int encrypted_length= public_encrypt(key_iv,
32,
repeater_pubkey,
encrypted);
if(encrypted_length == -1)
{
printLastError("Public Encrypt failed ");
exit(0);
}
printf("Encrypted length =%d\n",encrypted_length);
printf("Try to init_loop_cb...\n");
int base64_length = base64Encode(base64, encrypted, encrypted_length);
// printf("base64 len: %d\n", base64_length);
// printf("base64: %s\n", base64);
if(ubus_lookup_id(sys->tbus_ctx, "netapi", &id)){
dlog("can't lookup netapi\n");
goto fail;
}
blob_buf_init(&traffic_b, 0);
blobmsg_add_field(&traffic_b, BLOBMSG_TYPE_UNSPEC,
"data", base64, base64_length);
ubus_invoke(sys->tbus_ctx, id, "init", traffic_b.head,
receive_call_result_data, NULL, TRAFFICD_INIT_TIMEOUT);
free(encrypted);
free(base64);
return;
fail:
free(encrypted);
free(base64);
uloop_timeout_set(&sd->timeout_init, TRAFFICD_INIT_LOOP_TIME);
}
int main( int argc, char const *argv[])
{
int serverSock ;
int val = 1;
struct sockaddr_in serverAddr ;
struct sockaddr_in clientAddr ;
socklen_t clientAddrLen = sizeof (clientAddr);
char buffer [512];
char * uuid = random_uuid();
fprintf(stdout , "%s, %s\n" ,"Start", uuid);
fprintf(stdout , "%s, %s\n" ,"Another", random_uuid());
serverSock = socket(AF_INET, SOCK_STREAM , 0 );
if (serverSock == -1 ) {
fprintf (stderr, "%s\n" ,"open socket fail");
return - 1;
}
// Make sure the port can be immediately re-used
if (setsockopt(serverSock, SOL_SOCKET , SO_REUSEADDR, &val , sizeof(val )) < 0 ) {
fprintf (stderr, "%s\n" ,"can't reuse socket");
close (serverSock);
return - 1;
}
memset(&serverAddr , 0 , sizeof (serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr .s_addr = htonl(INADDR_ANY );
serverAddr.sin_port = htons(12345);
if (bind( serverSock, (struct sockaddr *) & serverAddr, sizeof(serverAddr )) != 0 ) {
fprintf (stderr, "%s\n" ,"can't bind socket");
close (serverSock);
return - 1;
}
// Listen to socket
fprintf(stdout , "%s\n" ,"start listen port 12345");
if (listen( serverSock, 1024) < 0 ) {
return - 1;
}
while(1){
//accept will wait for message coming
fprintf (stdout, "%s\n" ,"wait accept");
int clientSock = accept(serverSock , ( struct sockaddr *) &clientAddr, &clientAddrLen );
int total_byte_cnt = 0;
for (;;) {
int byteCount = read(clientSock , buffer + total_byte_cnt, sizeof(buffer ) - total_byte_cnt - 1);
if ( byteCount >= 0 ) {
total_byte_cnt += byteCount;
buffer [total_byte_cnt] = 0;
/*
fprintf (stdout, "[1] %d bytes read\n" , byteCount);
fprintf (stdout, "%s\n" , "========================" );
fprintf (stdout, "%s\n" , buffer);
fprintf (stdout, "%s\n" , "========================" );
*/
//
char *pch = strstr(buffer,"GET / HTTP/1.1");
char *Upgrade = extract_substring(buffer ,"Upgrade: ","\n");
char *Connection = extract_substring(buffer ,"Connection: ","\n");
//Sec-WebSocket-Protocol should be "chat"
char *Sec_WebSocket_Protocol = extract_substring(buffer ,"Sec-WebSocket-Protocol: ","\n");
if (pch == NULL) printf("pch is null");
//printf("[%s]\n", Upgrade);
//printf("[%s]\n", Connection);
if ((pch == buffer) && ((strcmp(Upgrade,"websocket") == 0) || (strcmp(Upgrade,"Websocket") == 0)) && ((strcmp(Connection,"Upgrade") == 0) || (strcmp(Connection,"keep-alive, Upgrade") == 0)) ){
handle_header(clientSock, buffer);
handle_message_loop(clientSock);
}
//
break;
} else {
//fprintf (stdout, "%s\n" ,"[3] oh no");
break;
}
}
}
fprintf(stdout , "%s\n" ,"Finish");
return 0;
}