/programs/develop/ktcc/trunk/libc.obj/include/clayer/boxlib.h |
---|
0,0 → 1,265 |
// writed by maxcodehack and superturbocat2001 |
// adaptation of clayer for ktcc |
#ifndef KOLIBRI_BOXLIB_H |
#define KOLIBRI_BOXLIB_H |
typedef unsigned color_t; |
extern int kolibri_boxlib_init(void); |
/* flags meaning */ |
#define ed_figure_only 0b1000000000000000 // одни символы |
#define ed_always_focus 0b100000000000000 // всегда с курсором (фокусом) |
#define ed_focus 0b10 // фокус ввода приложения, мышится самостоятельно |
#define ed_pass 0b1 // поле с паролем |
#define ed_shift_on 0b1000 // если не установлен -значит впервые нажат shift,если был установлен, значит мы уже что - то делали удерживая //shift |
#define ed_shift_on_off 0b1111111111110111 |
#define ed_shift 0b100 //включается при нажатии на shift т.е. если нажимаю |
#define ed_shift_off 0b1111111111111011 |
#define ed_shift_bac 0b10000 //бит для очистки выделеного shift т.е. при установке говорит что есть выделение |
#define ed_shift_bac_cl 0b1111111111101111 //очистка при удалении выделения |
#define ed_shift_cl 0b1111111111100011 |
#define ed_shift_mcl 0b1111111111111011 |
#define ed_left_fl 0b100000 |
#define ed_right_fl 0b1111111111011111 |
#define ed_offset_fl 0b1000000 |
#define ed_offset_cl 0b1111111110111111 |
#define ed_insert 0b10000000 |
#define ed_insert_cl 0b1111111101111111 |
#define ed_mouse_on 0b100000000 |
#define ed_mous_adn_b 0b100011000 |
#define ed_mouse_off ~ed_mouse_on |
#define ed_ctrl_on 0b1000000000 |
#define ed_ctrl_off ~ed_ctrl_on |
#define ed_alt_on 0b10000000000 |
#define ed_alt_off ~ed_alt_on |
#define ed_disabled 0b100000000000 |
// SCROLLBAR |
typedef struct { |
uint16_t xsize; |
uint16_t xpos; |
uint16_t ysize; |
uint16_t ypos; |
uint32_t btn_height; |
uint32_t type; // type 1 - stylish frame, type 2 - ?, type 0 - ? |
uint32_t max_area; |
uint32_t cur_area; |
uint32_t position; |
uint32_t back_color; |
uint32_t front_color; |
uint32_t line_color; |
uint32_t redraw; |
uint16_t delta; |
uint16_t delta2; |
uint16_t r_size_x; |
uint16_t r_start_x; |
uint16_t r_size_y; |
uint16_t r_start_y; |
uint32_t m_pos; |
uint32_t m_pos2; |
uint32_t m_keys; |
uint32_t run_size; |
uint32_t position2; |
uint32_t work_size; |
uint32_t all_redraw; // need to be set =1 before each redraw |
uint32_t ar_offset; |
} __attribute__ ((__packed__)) scrollbar; |
extern void (*scrollbar_h_draw __attribute__((__stdcall__)))(scrollbar*); |
extern void (*scrollbar_h_mouse __attribute__((__stdcall__)))(scrollbar*); |
extern void (*scrollbar_v_draw __attribute__((__stdcall__)))(scrollbar*); |
extern void (*scrollbar_v_mouse __attribute__((__stdcall__)))(scrollbar*); |
// CHECKBOX |
typedef struct { |
unsigned int left_s; |
unsigned int top_s; |
unsigned int ch_text_margin; |
unsigned int color; |
unsigned int border_color; |
unsigned int text_color; |
char *text; |
unsigned int flags; |
/* Users can use members above this */ |
unsigned int size_of_str; |
}check_box; |
extern void (*check_box_draw2 __attribute__((__stdcall__)))(check_box *); |
extern void (*check_box_mouse2 __attribute__((__stdcall__)))(check_box *); |
extern void (*init_checkbox2 __attribute__((__stdcall__)))(check_box *); |
// DBUTTON |
typedef struct { |
uint32_t type; |
uint32_t x_w; |
uint32_t y_h; |
uint32_t mouse_pos; |
uint32_t mouse_keys; |
uint32_t mouse_keys_old; |
void* active_raw; //active bitmap |
void* passive_raw; //passive bitmap |
void* click_raw; //pressed bitmap |
uint32_t resolution_raw; // bpp, as esi fn65 |
void* palette_raw; // palette, as edi fn65 |
uint32_t offset_raw; // width as ebp fn65 |
uint32_t select; // internal state: 0 - passive, 2 - pressed, 1 - clicked |
uint32_t click; // clicked - 1, zero it after tested |
} pict_button; |
extern void (*dynamic_button_draw __attribute__((__stdcall__)))(pict_button *); |
extern void (*dynamic_button_mouse __attribute__((__stdcall__)))(pict_button *); |
// EDITBOX |
#pragma pack(push,1) |
typedef struct edit_box_t { |
unsigned int width; |
unsigned int left; |
unsigned int top; |
unsigned int color; |
unsigned int shift_color; // selected text color |
unsigned int focus_border_color; |
unsigned int blur_border_color; |
unsigned int text_color; |
unsigned int max; |
char *text; |
void *mouse_variable; // must be pointer edit_box** to save focused editbox |
unsigned int flags; |
unsigned int size; // used symbols in buffer without trailing zero |
unsigned int pos; // cursor position |
/* The following struct members are not used by the users of API */ |
unsigned int offset; |
unsigned int cl_curs_x; |
unsigned int cl_curs_y; |
unsigned int shift; |
unsigned int shift_old; |
unsigned int height; |
unsigned int char_width; |
}edit_box; |
#pragma pack(pop) |
extern void (*edit_box_draw __attribute__((__stdcall__)))(edit_box *); |
extern void edit_box_key (edit_box *, unsigned int key_val)__attribute__((__stdcall__)); |
extern void (*edit_box_mouse __attribute__((__stdcall__)))(edit_box *); |
extern void (*edit_box_set_text __attribute__((__stdcall__)))(edit_box *, char *); |
// FRAME |
typedef struct { |
uint32_t type; |
uint32_t x_w; |
uint32_t y_h; |
color_t ext_col; |
color_t int_col; |
uint32_t flags; |
char *text_pointer; |
uint32_t text_position; |
uint32_t font_number; |
uint32_t font_size_y; |
color_t font_color; |
color_t font_bg_color; |
}frame; |
extern void (*frame_draw)(frame *); |
// MENUBAR |
typedef struct |
{ |
uint32_t type; // 1 åñëè íåò ïîäìåíþ, ïðîñòî ïóíêò |
uint32_t x_w; // âåðõíèé ïóíêò |
uint32_t y_h; |
char* text_pointer; |
char* pos_pointer; |
char* text_end; |
uint32_t mouse_pos; |
uint32_t mouse_keys; |
uint32_t x_w1; // ïîäìåíþ |
uint32_t y_h1; |
color_t bckg_col; // ôîí âåðõíåãî ïóêòà |
color_t frnt_col; // ôîí âûáðàííîãî âåðõíåãî ïóíêòà |
color_t menu_col; // ôîí âûïàäàþùåé ÷àñòè (ïîäïóêòû) |
uint32_t select; |
uint32_t out_select; |
char* buf_adress; |
char* procinfo; |
uint32_t click; |
uint32_t cursor; |
uint32_t cursor_old; |
uint32_t interval; |
uint32_t cursor_max; |
uint32_t extended_key; |
color_t menu_sel_col; // öâåò ôîíà âûáðàííîãî ïîäïóíêòà |
color_t bckg_text_col; // öâåò øðèôòà íåâûáðàííîãî ïóíêòà |
color_t frnt_text_col; // öâåò øðèôòà âûáðàííîãî ïóíêòà |
uint32_t mouse_keys_old; |
uint32_t font_height; |
uint32_t cursor_out; |
uint32_t get_mouse_flag; |
} menubar; |
extern void (*menu_bar_draw)(menubar *); |
extern void (*menu_bar_mouse)(menubar *); |
extern void (*menu_bar_activate)(menubar *); |
// OPTIONBOX |
typedef struct option_box_t { |
struct option_box_t **selected; |
uint16_t posx; |
uint16_t posy; |
uint32_t text_margin; // = 4 ðàññòîÿíèå îò ïðÿìîóãîëüíèêà ÷åê áîêñà äî íàäïèñè |
uint32_t size; // 12 ðàçìåð êâàäðàòà ÷åê áîêñà |
color_t color; |
color_t border_color; // individual border |
color_t text_color; |
char *text; |
uint32_t text_len; |
uint32_t flags; |
} __attribute__ ((__packed__)) option_box; |
extern void (*option_box_draw __attribute__((__stdcall__)))(option_box **); |
extern void (*option_box_mouse __attribute__((__stdcall__)))(option_box **); |
// PATHSHOW |
typedef struct { |
uint32_t type; |
uint32_t x_y; |
uint16_t font_size_x; // 6 - for font 0, 8 - for font 1 |
uint16_t area_size_x; |
uint32_t font_number; // 0 - monospace, 1 - variable, as fn4 (2bit only 0-3) |
uint32_t background_flag; // as fn4, if 0, bk_color unneeded |
color_t font_color; // as fn4 |
color_t background_color; // as fn4 |
char* text_pointer; // 4096 ? |
char* work_area_pointer; // 4096 ? |
uint32_t temp_text_length; |
} __attribute__ ((__packed__)) pathview; |
extern void (*path_show_prepare __attribute__((__stdcall__)))(pathview *); |
extern void (*path_show_draw __attribute__((__stdcall__)))(pathview *); |
// PROGRESSBAR |
typedef struct { |
unsigned int value; |
unsigned int left; |
unsigned int top; |
unsigned int width; |
unsigned int height; |
unsigned int style; |
unsigned int min; |
unsigned int max; |
unsigned int back_color; |
unsigned int progress_color; |
unsigned int frame_color; |
} progressbar; |
extern void (*progressbar_draw __attribute__((__stdcall__)))(progressbar *); |
extern void (*progressbar_progress __attribute__((__stdcall__)))(progressbar *); |
#endif /* KOLIBRI_BOXLIB_H */ |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/buf2d.h |
---|
0,0 → 1,83 |
#ifndef KOLIBRI_BUF2D_H |
#define KOLIBRI_BUF2D_H |
#include <stdint.h> |
/*ToDo |
* voxel function |
*/ |
extern int kolibri_buf2d_init(void); |
typedef struct { |
unsigned int *buf_pointer; |
uint16_t left; |
uint16_t top; |
unsigned int width; |
unsigned int height; |
unsigned int bgcolor; |
uint8_t color_bit; |
} __attribute__ ((__packed__))buf2d_struct; |
enum BUF2D_ALGORITM_FILTR { |
SIERRA_LITE, |
FLOYD_STEINBERG, |
BURKERS, |
HEAVYIRON_MOD, |
ATKINSON |
}; |
enum BUF2D_OPT_CROP { |
BUF2D_OPT_CROP_TOP = 1, |
BUF2D_OPT_CROP_LEFT = 2, |
BUF2D_OPT_CROP_BOTTOM = 4, |
BUF2D_OPT_CROP_RIGHT = 8 |
}; |
extern void (*buf2d_create_asm __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_curve_bezier_asm __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int); |
buf2d_struct* buf2d_create(uint16_t tlx, uint16_t tly, unsigned int sizex, unsigned int sizey, unsigned int font_bgcolor, uint8_t color_bit) |
{ |
buf2d_struct *new_buf2d_struct = (buf2d_struct *)malloc(sizeof(buf2d_struct)); |
new_buf2d_struct -> left = tlx; |
new_buf2d_struct -> top = tly; |
new_buf2d_struct -> width = sizex; |
new_buf2d_struct -> height = sizey; |
new_buf2d_struct -> bgcolor = font_bgcolor; |
new_buf2d_struct -> color_bit = color_bit; |
buf2d_create_asm(new_buf2d_struct); |
return new_buf2d_struct; |
} |
void buf2d_curve_bezier(buf2d_struct *buf, unsigned int p0_x, unsigned int p0_y, unsigned int p1_x, unsigned int p1_y, unsigned int p2_x, unsigned int p2_y, unsigned int color) |
{ |
buf2d_curve_bezier_asm(buf, (p0_x<<16)+p0_y, (p1_x<<16)+p1_y, (p2_x<<16)+p2_y, color); |
} |
extern void (*buf2d_draw __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_clear __attribute__((__stdcall__)))(buf2d_struct *, unsigned int); |
extern void (*buf2d_delete __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_rotate __attribute__((__stdcall__)))(buf2d_struct *, unsigned int); |
extern void (*buf2d_resize __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_line __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_line_sm __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_rect_by_size __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_filled_rect_by_size __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_circle __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_img_hdiv2 __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_img_wdiv2 __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_conv_24_to_8 __attribute__((__stdcall__)))(buf2d_struct *, unsigned int); |
extern void (*buf2d_conv_24_to_32 __attribute__((__stdcall__)))(buf2d_struct *, unsigned int); |
extern void (*buf2d_bit_blt_transp __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, buf2d_struct *); |
extern void (*buf2d_bit_blt_alpha __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, buf2d_struct *); |
extern void (*buf2d_convert_text_matrix __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_draw_text __attribute__((__stdcall__)))(buf2d_struct *, buf2d_struct *, const char *, unsigned int, unsigned int); |
extern void (*buf2d_crop_color __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int); |
extern void (*buf2d_offset_h __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_flood_fill __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int, unsigned int); |
extern void (*buf2d_set_pixel __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int, unsigned int); |
extern unsigned int (*buf2d_get_pixel __attribute__((__stdcall__)))(buf2d_struct *, unsigned int, unsigned int); |
extern void (*buf2d_flip_h __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_flip_v __attribute__((__stdcall__)))(buf2d_struct *); |
extern void (*buf2d_filter_dither __attribute__((__stdcall__)))(buf2d_struct *, unsigned int); |
#endif /* KOLIBRI_BUF2D_H */ |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/dialog.h |
---|
0,0 → 1,126 |
#ifndef KOLIBRI_DIALOG_H |
#define KOLIBRI_DIALOG_H |
#include <stdlib.h> |
#define NOT_SUCCESS 0 |
#define SUCCESS 1 |
char sz_com_area_name[] = "FFFFFFFF_open_dialog"; |
char sz_dir_default_path[] = "/rd/1"; |
char sz_start_path[] = "/rd/1/File managers/opendial"; |
char cd_com_area_name[] = "FFFFFFFF_color_dialog"; |
char cd_start_path[] = "/rd/1/colrdial"; |
enum open_dialog_mode { |
OPEN, |
SAVE, |
SELECT |
}; |
typedef struct { |
unsigned int size; |
unsigned char end; |
}od_filter __attribute__ ((__packed__)); |
typedef struct { |
unsigned int mode; |
char* procinfo; |
char* com_area_name; |
unsigned int com_area; |
char* opendir_path; |
char* dir_default_path; |
char* start_path; |
void (*draw_window)(); |
unsigned int status; |
char* openfile_path; |
char* filename_area; |
od_filter* filter_area; |
unsigned short x_size; |
unsigned short x_start; |
unsigned short y_size; |
unsigned short y_start; |
}open_dialog __attribute__ ((__packed__)); |
typedef struct{ |
unsigned int type; |
char* procinfo; |
char* com_area_name; |
unsigned int com_area; |
char* start_path; |
void (*draw_window)(void); |
unsigned int status; |
unsigned short x_size; |
unsigned short x_start; |
unsigned short y_size; |
unsigned short y_start; |
unsigned int color_type; |
unsigned int color; |
}color_dialog __attribute__ ((__packed__)); |
void fake_on_redraw(void) {} |
open_dialog* kolibri_new_open_dialog(unsigned int mode, unsigned short tlx, unsigned short tly, unsigned short x_size, unsigned short y_size) |
{ |
open_dialog *new_opendialog = (open_dialog *)malloc(sizeof(open_dialog)); |
od_filter *new_od_filter = (od_filter *)malloc(sizeof(od_filter)); |
char *plugin_path = (char *)calloc(4096, sizeof(char)); |
char *openfile_path = (char *)calloc(4096, sizeof(char)); |
char *proc_info = (char *)calloc(1024, sizeof(char)); |
char *filename_area = (char *)calloc(256, sizeof(char)); |
new_od_filter -> size = 0; |
new_od_filter -> end = 0; |
new_opendialog -> mode = mode; |
new_opendialog -> procinfo = proc_info; |
new_opendialog -> com_area_name = sz_com_area_name; |
new_opendialog -> com_area = 0; |
new_opendialog -> opendir_path = plugin_path; |
new_opendialog -> dir_default_path = sz_dir_default_path; |
new_opendialog -> start_path = sz_start_path; |
new_opendialog -> draw_window = &fake_on_redraw; |
new_opendialog -> status = 0; |
new_opendialog -> openfile_path = openfile_path; |
new_opendialog -> filename_area = filename_area; |
new_opendialog -> filter_area = new_od_filter; |
new_opendialog -> x_size = x_size; |
new_opendialog -> x_start = tlx; |
new_opendialog -> y_size = y_size; |
new_opendialog -> y_start = tly; |
return new_opendialog; |
} |
void cd_fake_on_redraw(void) {} |
color_dialog* kolibri_new_color_dialog(unsigned int type, unsigned short tlx, unsigned short tly, unsigned short x_size, unsigned short y_size) |
{ |
color_dialog *new_colordialog = (color_dialog *)malloc(sizeof(color_dialog)); |
char *proc_info = (char *)calloc(1024, sizeof(char)); |
new_colordialog -> type = type; |
new_colordialog -> procinfo = proc_info; |
new_colordialog -> com_area_name = cd_com_area_name; |
new_colordialog -> com_area = 0; |
new_colordialog -> start_path = cd_start_path; |
new_colordialog -> draw_window = &cd_fake_on_redraw; |
new_colordialog -> status = 0; |
new_colordialog -> x_size = x_size; |
new_colordialog -> x_start = tlx; |
new_colordialog -> y_size = y_size; |
new_colordialog -> y_start = tly; |
new_colordialog -> color_type = 0; |
new_colordialog -> color = 0; |
return new_colordialog; |
} |
extern void kolibri_dialog_init(); |
extern void (*OpenDialog_init __attribute__((__stdcall__)))(open_dialog *); |
extern void (*OpenDialog_start __attribute__((__stdcall__)))(open_dialog *); |
extern void (*ColorDialog_init __attribute__((__stdcall__)))(color_dialog *); |
extern void (*ColorDialog_start __attribute__((__stdcall__)))(color_dialog *); |
#endif |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/gb.h |
---|
0,0 → 1,19 |
#pragma pack(push, 1) |
typedef struct |
{ |
int w; |
int h; |
char *bmp; |
char *alpha; |
} GB_BMP; |
#pragma pack(pop) |
void gb_pixel_set(GB_BMP *b, int x, int y, unsigned c); |
int gb_pixel_get(GB_BMP *b, int x, int y, unsigned *c); |
void gb_line(GB_BMP *b, int x1, int y1, int x2, int y2, unsigned c); |
void gb_rect(GB_BMP *b, int x, int y, int w, int h, unsigned c); |
void gb_bar(GB_BMP *b, int x, int y, int w, int h, unsigned c); |
void gb_circle(GB_BMP *b, int x, int y, int r, unsigned c); |
void gb_image_set(GB_BMP *b_dest, int x_d, int y_d, GB_BMP *b_src, int x_s, int y_s, int w, int h); |
void gb_image_set_t(GB_BMP *b_dest, int x_d, int y_d, GB_BMP *b_src, int x_s, int y_s, int w, int h, unsigned c); |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/http.h |
---|
0,0 → 1,153 |
/* |
This is adapded thunk for http.obj sys library |
.h is equal to svn:\\programs\develop\libraries\http\http_en.txt |
Adapted for TCC's dynamic API by Magomed Kostoev, 2020 |
*/ |
#ifndef _HTTP_H_ |
#define _HTTP_H_ |
#define cdecl __attribute__ ((cdecl)) |
#define stdcall __attribute__ ((stdcall)) |
// Bitflags for http_msg.flags |
// status |
#define HTTP_FLAG_HTTP11 1 << 0 |
#define HTTP_FLAG_GOT_HEADER 1 << 1 |
#define HTTP_FLAG_GOT_ALL_DATA 1 << 2 |
#define HTTP_FLAG_CONTENT_LENGTH 1 << 3 |
#define HTTP_FLAG_CHUNKED 1 << 4 |
#define HTTP_FLAG_CONNECTED 1 << 5 |
// user options |
#define HTTP_FLAG_KEEPALIVE 1 << 8 |
#define HTTP_FLAG_STREAM 1 << 9 |
#define HTTP_FLAG_REUSE_BUFFER 1 << 10 |
#define HTTP_FLAG_BLOCK 1 << 11 |
// error |
#define HTTP_FLAG_INVALID_HEADER 1 << 16 |
#define HTTP_FLAG_NO_RAM 1 << 17 |
#define HTTP_FLAG_SOCKET_ERROR 1 << 18 |
#define HTTP_FLAG_TIMEOUT_ERROR 1 << 19 |
#define HTTP_FLAG_TRANSFER_FAILED 1 << 20 |
/* |
User flags: |
For the flag codes themselves, see http.inc file. |
FLAG_KEEPALIVE will keep the connection open after first GET/POST/.. so you can send a second request on the same TCP session. |
In this case, the session must be closed manually when done by using the exported disconnect() function. |
FLAG_STREAM will force receive() to put the received content in a series of fixed size buffers, instead of everything in one big buffer. |
This can be used for example to receive an internet radio stream, |
but also to download larger files for which it does not make sense to put them completely in RAM first. |
FLAG_REUSE_BUFFER is to be used in combination with FLAG_STREAM and will make receive() function re-use the same buffer. |
This, for example, can be used when downloading a file straight to disk. |
FLAG_BLOCK will make receive() function blocking. This is only to be used when receiving one file from a thread that has no other work. |
If however, you want to receive multiple files, or do other things in the program mainloop, you should call the receive function periodically. |
You may use system function 10 or 23 to wait for network event before calling one or more receive() functions. |
*/ |
#pragma pack(push,1) |
typedef struct http_msg_s { |
unsigned socket; // socket on which the actual transfer happens |
unsigned flags; // flags, reflects status of the transfer using bitflags |
unsigned write_ptr; // internal use only (where to write new data in buffer) |
unsigned buffer_length; // internal use only (number of available bytes in buffer) |
unsigned chunk_ptr; // internal use only (where the next chunk begins) |
unsigned timestamp; // internal use only (when last data was received) |
unsigned status; // HTTP status |
unsigned header_length; // length of HTTP header |
void * content_ptr; // ptr to content |
unsigned content_length; // total length of HTTP content |
unsigned content_received; // number of currently received content bytes |
char * http_header; |
} http_msg; |
#pragma pack(pop) |
/* |
url = pointer to ASCIIZ URL |
identifier = identifier of previously opened connection (keep-alive), or 0 to open a new one. |
flags = bit flags (see end of this document). |
add_header = pointer to ASCIIZ additional header parameters, or null for none. |
Every additional parameter must end with CR LF bytes, including the last line. |
Initiates a HTTP connection, using 'GET' method. |
Returns NULL on error, identifier otherwise. |
*/ |
extern http_msg * stdcall (*http_get)(const char *url, http_msg *identifier, unsigned flags, const char *add_header); |
/* |
url = pointer to ASCIIZ URL |
identifier = identifier of previously opened connection (keep-alive), or 0 to open a new one. |
flags = bit flags (see end of this document). |
add_header = pointer to ASCIIZ additional header parameters, or null for none. |
Every additional parameter must end with CR LF bytes, including the last line. |
Initiate a HTTP connection, using 'HEAD' method. |
Returns NULL on error, identifier otherwise. |
*/ |
extern http_msg * stdcall (*http_head)(const char *url, http_msg *identifier, unsigned flags, const char *add_header); |
/* |
url = pointer to ASCIIZ URL |
identifier = identifier of previously opened connection (keep-alive), or 0 to open a new one. |
flags = bit flags (see end of this document). |
add_header = pointer to ASCIIZ additional header parameters, or null for none. |
Every additional parameter must end with CR LF bytes, including the last line. |
content-type = pointer to ASCIIZ string containing content type. |
content-length = length of the content (in bytes). |
Initiate a HTTP connection, using 'POST' method. |
The content itself must be send to the socket (which you can find in the structure), |
using system function 75, 6. |
Returns 0 on error, identifier otherwise |
*/ |
extern http_msg * stdcall (*http_post)(const char *url, http_msg *identifier, unsigned flags, const char *add_header, |
const char *content_type, unsigned content_length); |
/* |
identifier = identifier which one of the previous functions returned |
This procedure will handle all incoming data for a connection and place it in the buffer. |
As long as the procedure expects more data, -1 is returned and the procedure must be called again. |
When transfer is done, the procedure will return 0. |
The receive procedure is non-blocking by default, but can be made to block by setting FLAG_BLOCK. |
The HTTP header is placed together with some flags and other attributes in the http_msg structure. |
This structure is defined in http.inc (and not copied here because it might still change.) |
The identifier used by the functions is actually a pointer to this structure. |
In the dword named .flags, the library will set various bit-flags indicating the status of the process. |
(When a transfer is done, one should check these bit-flags to find out if the transfer was error-free.) |
The HTTP header is placed at the end of this structure. The content is placed in another buffer. |
The dword .status contains the status code received from the server (e.g. 200 for OK). |
In header_length you'll find the length of the header as soon as it has been received. |
In content_ptr you'll find a pointer to the actual content. |
In content_length you'll find the length of the content. |
In content_received, you'll find the number of content bytes already received. |
*/ |
extern int stdcall (*http_receive)(http_msg *identifier); |
/* |
identifier = identifier which one of the previous functions returned |
dataptr = pointer to the data you want to send |
datalength = length of the data to send (in bytes) |
This procedure can be used to send data to the server (POST) |
Returns number of bytes sent, -1 on error |
*/ |
extern int stdcall (*http_send)(http_msg *identifier, void *dataptr, unsigned datalength); |
/* |
Sometimes the http_receive function receives incomplete data. If you have the same problem then a macro can help you: |
*/ |
extern int stdcall (*http_free)(http_msg *identifier); |
/* |
Free unused data |
*/ |
#define http_long_receive(x) while(http_receive(x)){}; |
#endif // _HTTP_H_ |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/inputbox.h |
---|
0,0 → 1,17 |
/* |
This is wrapper for Inputbox.obj sys library |
https://board.kolibrios.org/viewtopic.php?f=24&t=3767&sid=fd2ca95b24eec430db0c61d977f5d8ba#p71585 |
Adapted for TCC's dynamic API by Magomed Kostoev, 2020 |
*/ |
#ifndef __KOS__INPUTBOX__H________ |
#define __KOS__INPUTBOX__H________ |
#define cdecl __attribute__ ((cdecl)) |
#define stdcall __attribute__ ((stdcall)) |
extern unsigned stdcall (*InputBox)(void* Buffer, char* Caption, char* Prompt, char* Default, |
unsigned long Flags, unsigned long BufferSize, void* RedrawProc); |
#endif // __KOS__INPUTBOX__H________ |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/libimg.h |
---|
0,0 → 1,126 |
/* Written by turbocat2001 (Logaev Maxim) */ |
#ifndef KOLIBRI_LIBIMG_H |
#define KOLIBRI_LIBIMG_H |
#include <stddef.h> |
#include <stdbool.h> |
extern int kolibri_libimg_init(void); |
#define _stdcall __attribute__((__stdcall__)) |
//list of format id's |
#define LIBIMG_FORMAT_BMP 1 |
#define LIBIMG_FORMAT_ICO 2 |
#define LIBIMG_FORMAT_CUR 3 |
#define LIBIMG_FORMAT_GIF 4 |
#define LIBIMG_FORMAT_PNG 5 |
#define LIBIMG_FORMAT_JPEG 6 |
#define LIBIMG_FORMAT_TGA 7 |
#define LIBIMG_FORMAT_PCX 8 |
#define LIBIMG_FORMAT_XCF 9 |
#define LIBIMG_FORMAT_TIFF 10 |
#define LIBIMG_FORMAT_PNM 11 |
#define LIBIMG_FORMAT_WBMP 12 |
#define LIBIMG_FORMAT_XBM 13 |
#define LIBIMG_FORMAT_Z80 14 |
#pragma pack(push, 1) |
typedef struct{ |
uint32_t Checksum; // ((Width ROL 16) OR Height) XOR Data[0] ; ignored so far |
uint32_t Width; |
uint32_t Height; |
uint32_t Next; |
uint32_t Previous; |
uint32_t Type; // one of Image.bppN |
uint32_t* Data; |
uint32_t Palette; // used iff Type eq Image.bpp1, Image.bpp2, Image.bpp4 or Image.bpp8i |
uint32_t Extended; |
uint32_t Flags; // bitfield |
uint32_t Delay; // used iff Image.IsAnimated is set in Flags |
} Image; |
#pragma pack(pop) |
#define IMAGE_BPP8i 1 // indexed |
#define IMAGE_BPP24 2 |
#define IMAGE_BPP32 3 |
#define IMAGE_BPP15 4 |
#define IMAGE_BPP16 5 |
#define IMAGE_BPP1 6 |
#define IMAGE_BPP8g 7 // grayscale |
#define IMAGE_BPP2i 8 |
#define IMAGE_BPP4i 9 |
#define IMAGE_BPP8a 10 |
// scale type |
#define LIBIMG_SCALE_NONE 0 |
#define LIBIMG_SCALE_INTEGER 1 |
#define LIBIMG_SCALE_TILE 2 |
#define LIBIMG_SCALE_STRETCH 3 |
#define LIBIMG_SCALE_FIT_BOTH LIBIMG_SCALE_STRETCH |
#define LIBIMG_SCALE_FIT_MIN 4 |
#define LIBIMG_SCALE_FIT_RECT LIBIMG_SCALE_FIT_MIN |
#define LIBIMG_SCALE_FIT_WIDTH 5 |
#define LIBIMG_SCALE_FIT_HEIGHT 6 |
#define LIBIMG_SCALE_FIT_MAX 7 |
// interpolation algorithm |
#define LIBIMG_INTER_NONE 0 // use it with LIBIMG_SCALE_INTEGER, LIBIMG_SCALE_TILE, etc |
#define LIBIMG_INTER_BILINEAR 1 |
#define LIBIMG_INTER_BICUBIC 2 |
#define LIBIMG_INTER_LANCZOS 3 |
#define LIBIMG_INTER_DEFAULT LIBIMG_INTER_BILINEAR |
//error codes |
#define LIBIMG_ERROR_OUT_OF_MEMORY 1 |
#define LIBIMG_ERROR_FORMAT 2 |
#define LIBIMG_ERROR_CONDITIONS 3 |
#define LIBIMG_ERROR_BIT_DEPTH 4 |
#define LIBIMG_ERROR_ENCODER 5 |
#define LIBIMG_ERROR_SRC_TYPE 6 |
#define LIBIMG_ERROR_SCALE 7 |
#define LIBIMG_ERROR_INTER 8 |
#define LIBIMG_ERROR_NOT_INPLEMENTED 9 |
#define LIBIMG_ERROR_INVALID_INPUT 10 |
//encode flags (byte 0x02 of _common option) |
#define LIBIMG_ENCODE_STRICT_SPECIFIC 0x01 |
#define LIBIMG_ENCODE_STRICT_BIT_DEPTH 0x02 |
#define LIBIMG_ENCODE_DELETE_ALPHA 0x08 |
#define LIBIMG_ENCODE_FLUSH_ALPHA 0x10 |
#define FLIP_VERTICAL 0x01 |
#define FLIP_HORIZONTAL 0x02 |
#define ROTATE_90_CW 0x01 |
#define ROTATE_180 0x02 |
#define ROTATE_270_CW 0x03 |
#define ROTATE_90_CCW ROTATE_270_CW |
#define ROTATE_270_CCW ROTATE_90_CW |
extern Image* (*img_decode _stdcall)(void* file_data, uint32_t size, uint32_t b_color); |
extern Image* (*img_encode _stdcall)(Image* img, uint32_t length, uint32_t option); |
extern Image* (*img_create _stdcall)(uint32_t width, uint32_t height, uint32_t type); |
extern void (*img_to_rgb2 _stdcall)(Image* img, void *rgb_data); |
extern Image* (*img_to_rgb _stdcall)(Image* img); |
extern bool (*img_flip _stdcall)(Image* img, uint32_t flip); |
extern bool (*img_flip_layer _stdcall)(Image *img, uint32_t flip); |
extern bool (*img_rotate _stdcall)(Image *img, uint32_t rotate); |
extern bool (*img_rotate_layer _stdcall)(Image* data, uint32_t rotate); |
extern void (*img_draw _stdcall)(Image *img, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t xoff, uint32_t yoff); |
extern int32_t (*img_count _stdcall)(Image *img); |
extern bool (*img_destroy _stdcall)(Image *img); |
extern bool (*img_destroy_layer _stdcall)(Image* img); |
extern Image* (*img_blend _stdcall)(Image* dst, Image* src, uint32_t out_x, uint32_t out_y, uint32_t in_x, uint32_t in_y, uint32_t width, uint32_t height); |
extern Image* (*img_convert _stdcall)(Image *src, Image *dst, uint32_t dst_type, uint32_t, uint32_t); |
extern Image* (*img_resize_data _stdcall)(Image *src, uint32_t width, uint32_t height); |
extern Image* (*img_scale _stdcall)(Image* src, uint32_t crop_x, uint32_t crop_y, uint32_t crop_width, uint32_t crop_height, Image* dst, uint32_t scale_type, uint32_t inter, uint32_t new_width, uint32_t new_height); |
void img_fill_color(Image* img, uint32_t width, uint32_t height, uint32_t color){ |
for (uint32_t i = 0; i < width*height; i++) { |
img->Data[i] = color; |
} |
} |
#endif /* KOLIBRI_LIBIMG_H */ |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/msgbox.h |
---|
0,0 → 1,55 |
#ifndef KOLIBRI_MSGBOX_H |
#define KOLIBRI_MSGBOX_H |
#include <stdarg.h> |
#include <stddef.h> |
#include <stdlib.h> |
#include <string.h> |
typedef struct { |
uint8_t retval; // 0 - win closed, 1 to n - button num, also default button on start |
uint8_t reserv; |
char texts[2048]; // must be enough ;-) |
char msgbox_stack[1024]; |
uint32_t top_stack; |
}__attribute__((packed)) msgbox; |
typedef void (*msgbox_callback)(void); |
extern void (*msgbox_create __attribute__((__stdcall__)))(msgbox *, void *thread); // clears callbacks, ! if fix lib, we can return eax as of Fn51 |
extern void (*msgbox_setfunctions __attribute__((__stdcall__)))(msgbox_callback*); // must be called immediately after create, zero-ended array |
extern void (*msgbox_reinit __attribute__((__stdcall__)))(msgbox *) ; // recalc sizes when structure changes, called auto when MsgBoxCreate |
static inline msgbox* kolibri_new_msgbox(char* title, char* text, int def_but, ...) |
/// text can be multilined by code 13 = "\r" |
/// def_but - highlighted and used on Enter (if zero - default is [X]), user may use Tabs or Arrows |
/// last params are buttons text, max 8. last must set as NULL |
{ |
va_list vl=0; |
va_start(vl, def_but); |
msgbox* box = calloc(sizeof(msgbox), 1); |
box->retval = (uint8_t)def_but; |
char *pc = box->texts; |
strcpy(pc, title); |
pc += strlen(title) + 1; |
strcpy(pc, text); |
pc += strlen(text) + 1; |
char *but_text = va_arg(vl, char*); |
while (but_text) |
{ |
strcpy(pc, but_text); |
pc += strlen(but_text) + 1; |
but_text = va_arg(vl, char*); |
} |
va_end(vl); |
return box; |
} |
static inline void kolibri_start_msgbox(msgbox* box, msgbox_callback cb[]) |
{ |
(*msgbox_create)(box, &box->top_stack); |
if (cb) (*msgbox_setfunctions)(cb); |
} |
#endif |
/programs/develop/ktcc/trunk/libc.obj/include/clayer/rasterworks.h |
---|
0,0 → 1,11 |
#ifndef KOLIBRI_RASTERWORKS_H |
#define KOLIBRI_RASTERWORKS_H |
//extern int kolibri_rasterworks_init(void); |
extern void (*drawText __attribute__((__stdcall__)))(void *canvas, int x, int y, const char *string, int charQuantity, int fontColor, int params); |
extern int (*countUTF8Z __attribute__((__stdcall__)))(const char *string, int byteQuantity); |
extern int (*charsFit __attribute__((__stdcall__)))(int areaWidth, int charHeight); |
extern int (*strWidth __attribute__((__stdcall__)))(int charQuantity, int charHeight); |
#endif /* KOLIBRI_RASTERWORKS_H */ |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/aes.h |
---|
0,0 → 1,123 |
/********************************************************************* |
* Filename: aes.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding AES implementation. |
*********************************************************************/ |
#ifndef AES_H |
#define AES_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define AES_BLOCK_SIZE 16 // AES operates on 16 bytes at a time |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
/*********************** FUNCTION DECLARATIONS **********************/ |
/////////////////// |
// AES |
/////////////////// |
// Key setup must be done before any AES en/de-cryption functions can be used. |
void aes_key_setup(const BYTE key[], // The key, must be 128, 192, or 256 bits |
WORD w[], // Output key schedule to be used later |
int keysize); // Bit length of the key, 128, 192, or 256 |
void aes_encrypt(const BYTE in[], // 16 bytes of plaintext |
BYTE out[], // 16 bytes of ciphertext |
const WORD key[], // From the key setup |
int keysize); // Bit length of the key, 128, 192, or 256 |
void aes_decrypt(const BYTE in[], // 16 bytes of ciphertext |
BYTE out[], // 16 bytes of plaintext |
const WORD key[], // From the key setup |
int keysize); // Bit length of the key, 128, 192, or 256 |
/////////////////// |
// AES - CBC |
/////////////////// |
int aes_encrypt_cbc(const BYTE in[], // Plaintext |
size_t in_len, // Must be a multiple of AES_BLOCK_SIZE |
BYTE out[], // Ciphertext, same length as plaintext |
const WORD key[], // From the key setup |
int keysize, // Bit length of the key, 128, 192, or 256 |
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long |
// Only output the CBC-MAC of the input. |
int aes_encrypt_cbc_mac(const BYTE in[], // plaintext |
size_t in_len, // Must be a multiple of AES_BLOCK_SIZE |
BYTE out[], // Output MAC |
const WORD key[], // From the key setup |
int keysize, // Bit length of the key, 128, 192, or 256 |
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long |
/////////////////// |
// AES - CTR |
/////////////////// |
void increment_iv(BYTE iv[], // Must be a multiple of AES_BLOCK_SIZE |
int counter_size); // Bytes of the IV used for counting (low end) |
void aes_encrypt_ctr(const BYTE in[], // Plaintext |
size_t in_len, // Any byte length |
BYTE out[], // Ciphertext, same length as plaintext |
const WORD key[], // From the key setup |
int keysize, // Bit length of the key, 128, 192, or 256 |
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long |
void aes_decrypt_ctr(const BYTE in[], // Ciphertext |
size_t in_len, // Any byte length |
BYTE out[], // Plaintext, same length as ciphertext |
const WORD key[], // From the key setup |
int keysize, // Bit length of the key, 128, 192, or 256 |
const BYTE iv[]); // IV, must be AES_BLOCK_SIZE bytes long |
/////////////////// |
// AES - CCM |
/////////////////// |
// Returns True if the input parameters do not violate any constraint. |
int aes_encrypt_ccm(const BYTE plaintext[], // IN - Plaintext. |
WORD plaintext_len, // IN - Plaintext length. |
const BYTE associated_data[], // IN - Associated Data included in authentication, but not encryption. |
unsigned short associated_data_len, // IN - Associated Data length in bytes. |
const BYTE nonce[], // IN - The Nonce to be used for encryption. |
unsigned short nonce_len, // IN - Nonce length in bytes. |
BYTE ciphertext[], // OUT - Ciphertext, a concatination of the plaintext and the MAC. |
WORD *ciphertext_len, // OUT - The length of the ciphertext, always plaintext_len + mac_len. |
WORD mac_len, // IN - The desired length of the MAC, must be 4, 6, 8, 10, 12, 14, or 16. |
const BYTE key[], // IN - The AES key for encryption. |
int keysize); // IN - The length of the key in bits. Valid values are 128, 192, 256. |
// Returns True if the input parameters do not violate any constraint. |
// Use mac_auth to ensure decryption/validation was preformed correctly. |
// If authentication does not succeed, the plaintext is zeroed out. To overwride |
// this, call with mac_auth = NULL. The proper proceedure is to decrypt with |
// authentication enabled (mac_auth != NULL) and make a second call to that |
// ignores authentication explicitly if the first call failes. |
int aes_decrypt_ccm(const BYTE ciphertext[], // IN - Ciphertext, the concatination of encrypted plaintext and MAC. |
WORD ciphertext_len, // IN - Ciphertext length in bytes. |
const BYTE assoc[], // IN - The Associated Data, required for authentication. |
unsigned short assoc_len, // IN - Associated Data length in bytes. |
const BYTE nonce[], // IN - The Nonce to use for decryption, same one as for encryption. |
unsigned short nonce_len, // IN - Nonce length in bytes. |
BYTE plaintext[], // OUT - The plaintext that was decrypted. Will need to be large enough to hold ciphertext_len - mac_len. |
WORD *plaintext_len, // OUT - Length in bytes of the output plaintext, always ciphertext_len - mac_len . |
WORD mac_len, // IN - The length of the MAC that was calculated. |
int *mac_auth, // OUT - TRUE if authentication succeeded, FALSE if it did not. NULL pointer will ignore the authentication. |
const BYTE key[], // IN - The AES key for decryption. |
int keysize); // IN - The length of the key in BITS. Valid values are 128, 192, 256. |
/////////////////// |
// Test functions |
/////////////////// |
int aes_test(); |
int aes_ecb_test(); |
int aes_cbc_test(); |
int aes_ctr_test(); |
int aes_ccm_test(); |
#endif // AES_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/arcfour.h |
---|
0,0 → 1,30 |
/********************************************************************* |
* Filename: arcfour.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding ARCFOUR implementation. |
*********************************************************************/ |
#ifndef ARCFOUR_H |
#define ARCFOUR_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
/*********************** FUNCTION DECLARATIONS **********************/ |
// Input: state - the state used to generate the keystream |
// key - Key to use to initialize the state |
// len - length of key in bytes (valid lenth is 1 to 256) |
void arcfour_key_setup(BYTE state[], const BYTE key[], int len); |
// Pseudo-Random Generator Algorithm |
// Input: state - the state used to generate the keystream |
// out - Must be allocated to be of at least "len" length |
// len - number of bytes to generate |
void arcfour_generate_stream(BYTE state[], BYTE out[], size_t len); |
#endif // ARCFOUR_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/base64.h |
---|
0,0 → 1,27 |
/********************************************************************* |
* Filename: base64.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding Base64 implementation. |
*********************************************************************/ |
#ifndef BASE64_H |
#define BASE64_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
/*********************** FUNCTION DECLARATIONS **********************/ |
// Returns the size of the output. If called with out = NULL, will just return |
// the size of what the output would have been (without a terminating NULL). |
size_t base64_encode(const BYTE in[], BYTE out[], size_t len, int newline_flag); |
// Returns the size of the output. If called with out = NULL, will just return |
// the size of what the output would have been (without a terminating NULL). |
size_t base64_decode(const BYTE in[], BYTE out[], size_t len); |
#endif // BASE64_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/blowfish.h |
---|
0,0 → 1,32 |
/********************************************************************* |
* Filename: blowfish.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding Blowfish implementation. |
*********************************************************************/ |
#ifndef BLOWFISH_H |
#define BLOWFISH_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define BLOWFISH_BLOCK_SIZE 8 // Blowfish operates on 8 bytes at a time |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
typedef struct { |
WORD p[18]; |
WORD s[4][256]; |
} BLOWFISH_KEY; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void blowfish_key_setup(const BYTE user_key[], BLOWFISH_KEY *keystruct, size_t len); |
void blowfish_encrypt(const BYTE in[], BYTE out[], const BLOWFISH_KEY *keystruct); |
void blowfish_decrypt(const BYTE in[], BYTE out[], const BLOWFISH_KEY *keystruct); |
#endif // BLOWFISH_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/des.h |
---|
0,0 → 1,37 |
/********************************************************************* |
* Filename: des.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding DES implementation. |
Note that encryption and decryption are defined by how |
the key setup is performed, the actual en/de-cryption is |
performed by the same function. |
*********************************************************************/ |
#ifndef DES_H |
#define DESH |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define DES_BLOCK_SIZE 8 // DES operates on 8 bytes at a time |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
typedef enum { |
DES_ENCRYPT, |
DES_DECRYPT |
} DES_MODE; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void des_key_setup(const BYTE key[], BYTE schedule[][6], DES_MODE mode); |
void des_crypt(const BYTE in[], BYTE out[], const BYTE key[][6]); |
void three_des_key_setup(const BYTE key[], BYTE schedule[][16][6], DES_MODE mode); |
void three_des_crypt(const BYTE in[], BYTE out[], const BYTE key[][16][6]); |
#endif // DES_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/md2.h |
---|
0,0 → 1,33 |
/********************************************************************* |
* Filename: md2.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding MD2 implementation. |
*********************************************************************/ |
#ifndef MD2_H |
#define MD2_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define MD2_BLOCK_SIZE 16 |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef struct { |
BYTE data[16]; |
BYTE state[48]; |
BYTE checksum[16]; |
int len; |
} MD2_CTX; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void md2_init(MD2_CTX *ctx); |
void md2_update(MD2_CTX *ctx, const BYTE data[], size_t len); |
void md2_final(MD2_CTX *ctx, BYTE hash[]); // size of hash must be MD2_BLOCK_SIZE |
#endif // MD2_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/md5.h |
---|
0,0 → 1,34 |
/********************************************************************* |
* Filename: md5.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding MD5 implementation. |
*********************************************************************/ |
#ifndef MD5_H |
#define MD5_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define MD5_BLOCK_SIZE 16 // MD5 outputs a 16 byte digest |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
typedef struct { |
BYTE data[64]; |
WORD datalen; |
unsigned long long bitlen; |
WORD state[4]; |
} MD5_CTX; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void md5_init(MD5_CTX *ctx); |
void md5_update(MD5_CTX *ctx, const BYTE data[], size_t len); |
void md5_final(MD5_CTX *ctx, BYTE hash[]); |
#endif // MD5_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/rot-13.h |
---|
0,0 → 1,20 |
/********************************************************************* |
* Filename: rot-13.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding ROT-13 implementation. |
*********************************************************************/ |
#ifndef ROT13_H |
#define ROT13_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/*********************** FUNCTION DECLARATIONS **********************/ |
// Performs IN PLACE rotation of the input. Assumes input is NULL terminated. |
// Preserves each charcter's case. Ignores non alphabetic characters. |
void rot13(char str[]); |
#endif // ROT13_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/sha1.h |
---|
0,0 → 1,35 |
/********************************************************************* |
* Filename: sha1.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding SHA1 implementation. |
*********************************************************************/ |
#ifndef SHA1_H |
#define SHA1_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define SHA1_BLOCK_SIZE 20 // SHA1 outputs a 20 byte digest |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
typedef struct { |
BYTE data[64]; |
WORD datalen; |
unsigned long long bitlen; |
WORD state[5]; |
WORD k[4]; |
} SHA1_CTX; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void sha1_init(SHA1_CTX *ctx); |
void sha1_update(SHA1_CTX *ctx, const BYTE data[], size_t len); |
void sha1_final(SHA1_CTX *ctx, BYTE hash[]); |
#endif // SHA1_H |
/programs/develop/ktcc/trunk/libc.obj/include/cryptal/sha256.h |
---|
0,0 → 1,34 |
/********************************************************************* |
* Filename: sha256.h |
* Author: Brad Conte (brad AT bradconte.com) |
* Copyright: |
* Disclaimer: This code is presented "as is" without any guarantees. |
* Details: Defines the API for the corresponding SHA1 implementation. |
*********************************************************************/ |
#ifndef SHA256_H |
#define SHA256_H |
/*************************** HEADER FILES ***************************/ |
#include <stddef.h> |
/****************************** MACROS ******************************/ |
#define SHA256_BLOCK_SIZE 32 // SHA256 outputs a 32 byte digest |
/**************************** DATA TYPES ****************************/ |
typedef unsigned char BYTE; // 8-bit byte |
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines |
typedef struct { |
BYTE data[64]; |
WORD datalen; |
unsigned long long bitlen; |
WORD state[8]; |
} SHA256_CTX; |
/*********************** FUNCTION DECLARATIONS **********************/ |
void sha256_init(SHA256_CTX *ctx); |
void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len); |
void sha256_final(SHA256_CTX *ctx, BYTE hash[]); |
#endif // SHA256_H |