Skip to content

Commit b8fe4dd

Browse files
courectacourecta
committed
cs50 update
1 parent 21715c0 commit b8fe4dd

33 files changed

+1234
-386
lines changed

‎2023/rework/final/fin03.c‎

Lines changed: 157 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,157 @@
1+
#include "firewall.h"
2+
3+
typedef int32_t (*RuleFunctionPointer)(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size);
4+
5+
// Rule 1: If source ID is 1, set destination ID to 5.
6+
int32_t rule1(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size)
7+
{
8+
if (p_input_packet == NULL || input_size <= 0)
9+
{
10+
return -1;
11+
}
12+
13+
*pp_output_packet = (uint8_t *)malloc(input_size * sizeof(uint8_t));
14+
memcpy(*pp_output_packet, p_input_packet, input_size * sizeof(uint8_t));
15+
16+
uint32_t source_id = ((uint32_t *)p_input_packet)[0];
17+
printf("rule1: id: %d\n", source_id);
18+
if (source_id == 1)
19+
{
20+
((uint32_t *)(*pp_output_packet))[1] = 5; // change destination ID to 5.
21+
}
22+
23+
*p_output_size = input_size;
24+
return 0;
25+
}
26+
27+
// Rule 2: If source ID is 2, set source ID to 7.
28+
int32_t rule2(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size)
29+
{
30+
if (p_input_packet == NULL || input_size <= 0)
31+
{
32+
return -1;
33+
}
34+
35+
*pp_output_packet = (uint8_t *)malloc(input_size * sizeof(uint8_t));
36+
memcpy(*pp_output_packet, p_input_packet, input_size * sizeof(uint8_t));
37+
38+
uint32_t source_id = ((uint32_t *)p_input_packet)[0];
39+
printf("rule2: id: %d\n", source_id);
40+
if (source_id == 2)
41+
{
42+
((uint32_t *)(*pp_output_packet))[0] = 7; // change destination ID to 7.
43+
}
44+
45+
*p_output_size = input_size;
46+
return 0;
47+
}
48+
49+
// // Rule 3: If size is 2, duplicate data.
50+
int32_t rule3(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size)
51+
{
52+
if (p_input_packet == NULL || input_size <= 0)
53+
{
54+
return -1;
55+
}
56+
57+
uint16_t packet_size = ((uint16_t *)p_input_packet)[4];
58+
printf("rule3: size: %d\n", packet_size);
59+
if (packet_size == 2)
60+
{
61+
*pp_output_packet = (uint8_t*)malloc((input_size + packet_size) * sizeof(uint8_t));
62+
memcpy(*pp_output_packet, p_input_packet, input_size * sizeof(uint8_t));
63+
memcpy(*pp_output_packet + input_size, p_input_packet + input_size - packet_size, packet_size * sizeof(uint8_t)); // duplicate data
64+
*p_output_size = input_size + packet_size;
65+
}
66+
else
67+
{
68+
*pp_output_packet = (uint8_t *)malloc(input_size * sizeof(uint8_t));
69+
memcpy(*pp_output_packet, p_input_packet, input_size * sizeof(uint8_t));
70+
*p_output_size = input_size;
71+
}
72+
73+
return 0;
74+
}
75+
76+
// Rule 4: If source ID is 7 and destination ID is 3, Drop the packet.
77+
int32_t rule4(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size)
78+
{
79+
if (p_input_packet == NULL || input_size <= 0)
80+
{
81+
return -1;
82+
}
83+
84+
uint32_t source_id = ((uint32_t *)p_input_packet)[0];
85+
uint32_t destination_id = ((uint32_t *)p_input_packet)[1];
86+
87+
printf("rule4: s_id: %d, d_id: %d\n", source_id, destination_id);
88+
if (source_id == 7 && destination_id == 3)
89+
{
90+
return 1; // drop signal
91+
}
92+
93+
*pp_output_packet = (uint8_t *)malloc(input_size * sizeof(uint8_t));
94+
memcpy(*pp_output_packet, p_input_packet, input_size * sizeof(uint8_t));
95+
*p_output_size = input_size;
96+
return 0;
97+
}
98+
99+
int main()
100+
{
101+
uint8_t array[] = { 0x01, 0x00, 0x00, 0x00, // Packet 1 -> Source ID: 1
102+
0x02, 0x00, 0x00, 0x00, // Destination ID: 2
103+
0x03, 0x00, // Size
104+
0x01, 0x02, 0x03, // Data
105+
0x01, 0x00, 0x00, 0x00, // Packet 2 -> Source ID: 1
106+
0x03, 0x00, 0x00, 0x00, // Destination ID: 3
107+
0x02, 0x00, // Size
108+
0xEE, 0xFF, // Data
109+
0x02, 0x00, 0x00, 0x00, // Packet 3 -> Source ID: 2
110+
0x03, 0x00, 0x00, 0x00, // Destination ID: 3
111+
0x04, 0x00, // Size
112+
0x00, 0x00, 0x01, 0x02 // Data
113+
};
114+
115+
size_t array_len = sizeof(array)/sizeof(array[0]);
116+
117+
uint8_t *inputPacket = malloc(array_len * sizeof(uint8_t));
118+
memcpy(inputPacket, array, array_len);
119+
int32_t inputSize = array_len;
120+
uint8_t *outputPacket = NULL;
121+
int32_t outputSize = 0;
122+
123+
printf("rule1: %d\n", set_rule(0, rule1));
124+
printf("rule2: %d\n", set_rule(10, rule2));
125+
printf("rule3: %d\n", set_rule(20, rule3));
126+
printf("rule4: %d\n", set_rule(99, rule4));
127+
printf("filter: %d\n", filter(inputPacket, inputSize, &outputPacket, &outputSize));
128+
129+
uint8_t ans_array[] = { 0x01, 0x00, 0x00, 0x00, // Packet 1 -> Source ID: 1
130+
0x05, 0x00, 0x00, 0x00, // Destination ID: 5
131+
0x03, 0x00, // Size
132+
0x01, 0x02, 0x03, // Data
133+
0x01, 0x00, 0x00, 0x00, // Packet 2 -> Source ID: 1
134+
0x05, 0x00, 0x00, 0x00, // Destination ID: 5
135+
0x04, 0x00, // Size
136+
0xEE, 0xFF, 0xEE, 0xFF // Data
137+
};
138+
139+
printf("input_size: %d, output_size: %d\n", inputSize, outputSize);
140+
for (int i = 0; i < inputSize; i++)
141+
{
142+
printf("%d, ", inputPacket[i]);
143+
}
144+
printf("\n");
145+
for (int i = 0; i < outputSize; i++)
146+
{
147+
printf("%d, ", outputPacket[i]);
148+
}
149+
printf("\n");
150+
for (int i = 0; i < sizeof(ans_array)/sizeof(ans_array[0]); i++)
151+
{
152+
printf("%d, ", ans_array[i]);
153+
}
154+
155+
printf("\n=============end===========\n");
156+
return 0;
157+
}

‎2023/rework/final/firewall.c‎

Lines changed: 72 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,77 @@
1-
#include <stdio.h>
1+
#include "firewall.h"
22

3-
int main(){
3+
typedef int32_t (*RuleFunctionPointer)(const uint8_t *p_input_packet, const int32_t input_size, uint8_t **pp_output_packet, int32_t *p_output_size);
44

5+
RuleFunctionPointer rules[MAX_RULES] = {NULL};
6+
7+
int32_t set_rule(int32_t idx, RuleFunctionPointer rule)
8+
{
9+
if (idx < 0 || idx >= MAX_RULES || rule == NULL)
10+
{
11+
return -1;
12+
}
13+
14+
rules[idx] = rule;
15+
return 0;
16+
}
17+
18+
int32_t unset_rule(int32_t idx)
19+
{
20+
if (idx < 0 || idx >= MAX_RULES)
21+
{
22+
return -1;
23+
}
524

25+
rules[idx] = NULL;
26+
return 0;
27+
}
28+
29+
int32_t filter(const uint8_t *p_input_packets,
30+
const int32_t input_size,
31+
uint8_t **pp_output_packets,
32+
int32_t *p_output_size)
33+
{
34+
if (p_input_packets == NULL || input_size <= 0)
35+
{
36+
return -1;
37+
}
38+
*p_output_size = 0;
39+
40+
for (int count = 0; count < input_size;)
41+
{
42+
const uint8_t *p_input_packet = &(p_input_packets[count]);
43+
const uint32_t p_input_packet_size = ((uint16_t *)(p_input_packet))[4] + OFFSET; // data_size + offset
44+
45+
uint8_t *tmp_input_packet = malloc(p_input_packet_size * sizeof(uint8_t));
46+
memcpy(tmp_input_packet, p_input_packet, p_input_packet_size * sizeof(uint8_t));
47+
uint32_t tmp_input_size = p_input_packet_size;
48+
int32_t result = 0;
49+
50+
for (int i = 0; i < MAX_RULES; i++)
51+
{
52+
if (rules[i] == NULL) continue;
53+
uint8_t *tmp_output_packet = NULL;
54+
int32_t tmp_output_size = 0;
55+
56+
result = rules[i](tmp_input_packet, tmp_input_size, &tmp_output_packet, &tmp_output_size);
57+
58+
if (result == 1) break;
59+
else if (result == -1) continue;
60+
61+
free(tmp_input_packet);
62+
tmp_input_packet = malloc(tmp_output_size * sizeof(uint8_t));
63+
tmp_input_size = tmp_output_size;
64+
memcpy(tmp_input_packet, tmp_output_packet, tmp_output_size * sizeof(uint8_t));
65+
free(tmp_output_packet);
66+
}
667

68+
if(result != 1)
69+
{
70+
*pp_output_packets = realloc(*pp_output_packets, (*p_output_size + tmp_input_size) * sizeof(uint8_t));
71+
memcpy(*pp_output_packets + (*p_output_size), tmp_input_packet, tmp_input_size * sizeof(uint8_t));
72+
(*p_output_size) += tmp_input_size;
73+
}
74+
count += p_input_packet_size;
75+
}
776
return 0;
8-
}
77+
}

‎2023/rework/final/firewall.h‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
#pragma once
2+
3+
#include <stdio.h>
4+
#include <stdlib.h>
5+
#include <stdint.h>
6+
#include <string.h>
7+
8+
#define MAX_RULES (100)
9+
#define OFFSET (10)
10+
11+
int32_t set_rule(int32_t idx, int32_t (*rule)(const uint8_t* p_input_packet , const int32_t input_size , uint8_t** pp_output_packet , int32_t* p_output_size ));
12+
13+
// Set rule[idx] to NULL. If the inputs are invalid , return -1; otherwise , return 0.
14+
int32_t unset_rule(int32_t idx);
15+
16+
/*
17+
For every input packet , apply all rules on the packet and store every ouput
18+
packet on the pp_output_packets.
19+
If the inputs are invalid , return -1; otherwise , return 0.
20+
*/
21+
int32_t filter(const uint8_t *p_input_packets , const int32_t input_size , uint8_t **pp_output_packets , int32_t *p_output_size);

‎2023/rework/hw05/hw0504.c‎

Lines changed: 27 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,35 @@
1-
#include "mytlv.h"
1+
#include "tlv.h"
22

3-
size_t take(uint8_t *bytes){
4-
size_t size = 0;
3+
size_t take(uint8_t *bytes) {
4+
size_t size = 0;
5+
while(1)
6+
{
7+
int byte = 0;
58

6-
while (true) {
7-
int32_t byte = 0;
8-
scanf("%X", &byte);
9+
// Skip non-hexadecimal characters like '[', ']', and ','
10+
if (scanf(" %*[^0-9a-fA-F]") == EOF) break; // Stop if end-of-input is reached
911

10-
if (byte == 0xFF) {
11-
break;
12-
}
12+
// Parse a hexadecimal value
13+
if (scanf("%x", &byte) != 1) break; // Stop if no more valid hex values
1314

14-
bytes[size++] = byte;
15-
}
15+
// Terminate if 0xFF is encountered
16+
if (byte == 0xFF)
17+
{
18+
bytes[size++] = (uint8_t)byte;
19+
break;
20+
}
1621

17-
return size;
22+
bytes[size++] = (uint8_t)byte;
23+
}
24+
return size;
1825
}
1926

20-
int main() {
21-
uint8_t bytes[1024];
22-
size_t size = take(bytes);
23-
24-
int32_t result = run(bytes, size);
25-
26-
if (result == -1) {
27-
printf("\n======\nERROR DETECTED\n");
28-
}
29-
30-
return EXIT_SUCCESS;
27+
int main(void) {
28+
uint8_t bytes[1024];
29+
size_t size = take(bytes);
30+
int32_t result = run(bytes, size);
31+
if (result == -1) {
32+
printf("\n======\nERROR DETECTED\n");
33+
}
34+
return EXIT_SUCCESS;
3135
}

0 commit comments

Comments
 (0)