--- /dev/null
+cmake_minimum_required (VERSION 2.6)
+
+project (libtest)
+
+set(CMAKE_CXX_FLAGS "-g -Wall")
+set(CMAKE_C_FLAGS_DEBUG "-g -pg")
+
+ADD_SUBDIRECTORY(libuu)
+
+include_directories(libuu)
+link_directories(libuu)
+
+add_definitions(-DDEBUG)
+
+ADD_EXECUTABLE(libtest libtest.c)
+
+target_link_libraries(libtest uutest_lib)
+
+
<FORM METHOD=post ACTION=./index.php>
<TABLE border=0 WIDTH=80% height=1%>
-<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $login_name; ?>'>
-<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'>
-<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'>
+<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $_login_name; ?>'>
+<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'>
+<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'>
<tr>
<td>画面選択</td><td>
<FORM METHOD=post ACTION=./index.php>
<TABLE border=0 WIDTH=80% height=1%>
-<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $login_name; ?>'>
-<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'>
-<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'>
+<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $_login_name; ?>'>
+<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'>
+<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'>
<tr>
<td>画面選択</td><td>
<FORM METHOD=post ACTION=./index.php>
<TABLE border=0 WIDTH=80% height=1%>
<tr>
-<td>LOGIN NAME</td><td> <INPUT type=text size=24 name=LOGIN_NAME value='<?php echo $login_name; ?>'></td>
+<td>LOGIN NAME</td><td> <INPUT type=text size=24 name=LOGIN_NAME value='<?php echo $_login_name; ?>'></td>
</tr>
<tr>
-<td>PASS WORD</td><td> <INPUT type=hidden name=SET value=<?php echo $set; ?>>
-<INPUT type=password size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'></td>
+<td>PASS WORD</td><td> <INPUT type=hidden name=SET value=<?php echo $_set; ?>>
+<INPUT type=password size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'></td>
</tr>
<tr>
<td>SUBMIT</td><td> <INPUT TYPE=SUBMIT value=submit></td>
<FORM METHOD=post ACTION=./index.php>
<TABLE border=0 WIDTH=80% height=1%>
<tr>
-<td>LOGIN NAME</td><td> <INPUT type=text size=24 name=LOGIN_NAME value='<?php echo $login_name; ?>'></td>
+<td>LOGIN NAME</td><td> <INPUT type=text size=24 name=LOGIN_NAME value='<?php echo $_login_name; ?>'></td>
</tr>
<tr>
-<td>PASS WORD</td><td> <INPUT type=hidden name=SET value=<?php echo $set; ?>><INPUT type=password size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'></td>
+<td>PASS WORD</td><td> <INPUT type=hidden name=SET value=<?php echo $_set; ?>><INPUT type=password size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'></td>
</tr>
<tr>
<td>SUBMIT</td><td> <INPUT TYPE=SUBMIT value=submit></td>
<FORM METHOD=post ACTION=./index.php>
<TABLE border=0 WIDTH=80% height=1%>
-<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $login_name; ?>'>
-<INPUT type=hidden name=SET value=<?php echo $set; ?>>
-<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $pass_word; ?>'>
+<INPUT type=hidden size=24 name=LOGIN_NAME value='<?php echo $_login_name; ?>'>
+<INPUT type=hidden name=SET value=<?php echo $_set; ?>>
+<INPUT type=hidden size=24 name=PASS_WORD value='<?php echo $_pass_word; ?>'>
<tr>
<td>ログインに戻る</td><td> <INPUT TYPE=SUBMIT value=submit></td>
}
else{
- if(0 == strcmp($_SESSION['session_data'], md5(($login_name . $pass_word . $_SESSION['session_time'])))){
+ if(0 == strcmp($_SESSION['session_data'], md5(($_login_name . $_pass_word . $_SESSION['session_time'])))){
$_SESSION['count']++;
$_session = 1;
}
$_SESSION['session_time'] = time();
$_SESSION['session_val'] = time();
- $_SESSION['session_data'] = md5(($login_name . $pass_word . $_SESSION['session_time']));
+ $_SESSION['session_data'] = md5(($_login_name . $_pass_word . $_SESSION['session_time']));
$_SESSION['count'] = 1;
$_session = 1;
// --- グローバル変数設定 ---
date_default_timezone_set('Asia/Tokyo');
-$set = 0;
-$login_name ="";
-$pass_word ="";
+$_set = 0;
+$_login_name ="";
+$_pass_word ="";
$_session = 0;
// --- POST データの処理 ---
if (!empty($_POST)){
$SET = htmlspecialchars((int)$_POST["SET"]);
- if(preg_match("/^[0-9]+$/", $SET)){ $set = $SET; } else{ $set = 0; }
+ if(preg_match("/^[0-9]+$/", $SET)){ $_set = $SET; } else{ $_set = 0; }
- $login_name = htmlspecialchars($_POST["LOGIN_NAME"]);
- $pass_word = htmlspecialchars($_POST["PASS_WORD"]);
+ $_login_name = htmlspecialchars($_POST["LOGIN_NAME"]);
+ $_pass_word = htmlspecialchars($_POST["PASS_WORD"]);
}
-echo "== index.php ======= set= $set login_name= $login_name pass_word= $pass_word =====<br>\n";
+echo "== index.php ======= _set= $_set _login_name= $_login_name _pass_word= $_pass_word =====<br>\n";
// --- 画面処理 ---
-// --- set0 初期 LOGIN ---
-if( $set == 0 ){
- $set = 1;
+// --- _set0 初期 LOGIN ---
+if( $_set == 0 ){
+ $_set = 1;
include './include/html/html_login1.inc'; // ログイン画面に飛ぶ
}
-// --- set1 認証確認 ---
-else if( $set == 1 ){
- if(0 == strcmp("masashi@ms-n.com", $login_name) && 0 == strcmp("1234567890", $pass_word)){ // はじめの認証設定
+// --- _set1 認証確認 ---
+else if( $_set == 1 ){
+ if(0 == strcmp("masashi@ms-n.com", $_login_name) && 0 == strcmp("1234567890", $_pass_word)){ // はじめの認証設定
include './include/php/session_start.inc'; // セッション 開始処理
- $set = 3;
+ $_set = 3;
include './include/html/html_list.inc'; // ログイン完了画面に飛ぶ
}
else{
- $set = 1;
+ $_set = 1;
include './include/html/html_login2.inc'; // ログイン失敗後の再ログイン画面に飛ぶ
}
}
-// --- set2 ログイン失敗後の再ログイン画面 ---
-else if( $set == 2 ){
- $set = 1;
+// --- _set2 ログイン失敗後の再ログイン画面 ---
+else if( $_set == 2 ){
+ $_set = 1;
include './include/html/html_login2.inc'; // ログイン失敗後の再ログイン画面に飛ぶ
}
-// --- set3 ログイン完了画面 （一覧画面） ---
-else if( $set == 3 ){
+// --- _set3 ログイン完了画面 （一覧画面） ---
+else if( $_set == 3 ){
include './include/php/session_check.inc'; // セッション 確認処理
if($_session == 1){
- $set = 3;
+ $_set = 3;
include './include/html/html_list.inc';
}
else{
- $set = 1;
+ $_set = 1;
include './include/html/html_login1.inc'; // ログイン画面に飛ぶ
}
}
-// --- set4 ログアウト完了画面---
-else if( $set == 4 ){
+// --- _set4 ログアウト完了画面---
+else if( $_set == 4 ){
include './include/php/session_destroy.inc'; // セッション破壊処理
- $set = 0;
+ $_set = 0;
include './include/html/html_logout.inc';
}
-// --- set5 ログイン完了画面 （編集画面）---
-else if( $set == 5 ){
+// --- _set5 ログイン完了画面 （編集画面）---
+else if( $_set == 5 ){
include './include/php/session_check.inc'; // セッション 確認処理
if($_session == 1){
- $set = 5;
+ $_set = 5;
include './include/html/html_edit.inc';
}
else{
- $set = 1;
+ $_set = 1;
include './include/html/html_login1.inc'; // ログイン画面に飛ぶ
}
}
// --- それら以外の処理画面
else{
include './include/php/session_destroy.inc'; // セッション破壊処理
- $set = 1;
+ $_set = 1;
include './include/html/html_login1.inc'; // ログイン画面に飛ぶ
}
--- /dev/null
+cmake_minimum_required (VERSION 2.6)
+
+project (libtest)
+
+set(CMAKE_CXX_FLAGS "-g -Wall")
+set(CMAKE_C_FLAGS_DEBUG "-g -pg")
+
+ADD_SUBDIRECTORY(libuu)
+
+include_directories(libuu)
+link_directories(libuu)
+
+add_definitions(-DDEBUG)
+
+ADD_EXECUTABLE(libtest libtest.c)
+
+target_link_libraries(libtest uutest_lib)
+
+
--- /dev/null
+// libms.h
+// $Id: libms.h,v 2.0 2014/02/20 masashi Exp $
+// masashi shimakura
+
+
+#ifndef _ALMEMSYS_H_
+ #define _ALMEMSYS_H_
+
+ #ifndef _STDIO_H_
+ #include<stdio.h>
+ #endif
+
+ #ifndef _TIME_H_
+ #include<time.h>
+ #endif
+
+ #ifndef _INET_H_
+ #include<arpa/inet.h>
+ #endif
+
+ #ifndef _NETINET_IN_H_
+ #include<netinet/in.h>
+ #endif
+
+ #ifndef _NETDB_H
+ #include<netdb.h>
+ #endif
+
+ #ifndef _UNISTD_H_
+ #include<unistd.h>
+ #endif
+
+
+ #define CL_VER "almemsys-1.0.8"
+
+ #define HAVE_STDARGS
+ #define VA_LOCAL_DECL va_list ap;
+ #define VA_START(f) va_start(ap, f)
+ #define VA_SHIFT(v,t) ;
+ #define VA_END va_end(ap)
+
+ #ifndef BUF_DEFLEN
+ #define BUF_DEFLEN 128
+ #endif
+ #ifndef BUF_LEN
+ #define BUF_LEN 4096
+ #endif
+ #ifndef BUF_MAX
+ #define BUF_MAX (1024 * 1024 * 2)
+ #endif
+
+// debug option
+// #define AL_DEBUG
+// #define SOCKET_BUG
+// #define FDCAT_BUG
+// #define SEND_RECV_BUG
+// #define MIME_BASE64_BUG
+
+ struct th_str {
+ pthread_t t1;
+ pthread_t t2;
+ pthread_mutex_t read_mutex;
+ int th_sk;
+ int th_timeout;
+ int th_out;
+ int th_stat;
+ int th_ret;
+ int th_count;
+ char th_cha[64];
+ };
+
+
+
+ /* ---- bufer ---- */
+ int mem_count(char [], char);
+ int mem_tcount(char [], char);
+ int char_count(char [], char);
+ int rm_char(char [], char);
+ int char_point(char *, char, int);
+ int char_get(char *, char *, char, int);
+ int clean_mem(char [], char, int);
+ int set_mem(char [], char, int);
+ int rm_crlf(char [], int);
+ int swap_mem(char [], char, char);
+ int swap_armem(char [], char, char, int, int);
+ int chmem(char [], int);
+ int self_memcpy(char *, char *, int);
+ int self_strncat(char *, char *, int);
+ int self_delim_get(char *, char *, char, int, int);
+ char * delim_f(char * base, char * backdata, char deli, int count);
+ char * delim_r(char * base, char * backdata, char deli, int count);
+
+ int count_memcpy(char *, char *, int);
+ char * count_memcpy2(char *, char *, int, int);
+ int delim_count(char *, char, int, int *, int *);
+ int memcount_cpm(char *, char *, int, int, int);
+ int ch_int(char *);
+ int ch_int2(char *);
+ int ch_float(char *);
+ int ch_int3(char *, char);
+ int ch_int4(char *, char);
+ int ch_int_v6(char *);
+ int ch_int_v4(char *);
+ char * ch_char(char *, char *);
+ int self_memcmp(char *, char *);
+ int alversion(void);
+ int mlexit(void);
+ int self_delim_get(char *, char *, char, int, int);
+
+ /* --- heep bufer ---- */
+ char * safe_fpcat(FILE *, char *, int *, int);
+ char * safe_fdcpm(int, char *, int *, int, int);
+ char * safe_fdcat(int, char *, int *, int, int);
+ char * safe_filefdcat(int, char *, int *, int, int);
+ char * safe_memcpy(char *, char *, int);
+ char * safe_strncat(char *, char *, int);
+ char * safe_sprintf(char *, long int, const char *,...);
+ char * delim_get(char *, char *, char, int *, int);
+ char * swap_rn(char *, char);
+ char * safe_ujtoj(char *);
+ char * safe_base64(char *);
+ char * safe_base64inheader(char *, char *);
+ char * mime_ujtoj(char *);
+ char * null_free(char *);
+
+ /* --- socket --- */
+ int socket_reada(int, char *, int);
+ int socket_readas(int, char *, int, int, int);
+ int socket_readasth(int sk, char * readdata, int max, int interval, int mode, int * size);
+ int socket_reads(int, char * , int, int);
+ int socket_sends(int, char *, int, char);
+ int socket_send(int, char *, int);
+ int socket_send2(int, char *, int, int *);
+ char * select_fdcat(int sk, char * getdata, int * ret, int max, int interval);
+
+ /* --- file --- */
+ int file_copy(char *, char *);
+ char * alget_read(char *, char *, int, int, int *, char, int, int);
+ int alget_write(int, FILE *, int, char, int, int);
+ int unlinkdir(char *);
+
+ /* --- sp --- */
+ int base64(char *, int, char *);
+ char * base64_kai(char *);
+ int ujtoj(unsigned char *, unsigned char *);
+ int randdata(int, int);
+ int counts(char *, int, int);
+ int convert(const char *, const char *, const char *, char *, size_t);
+ int self_convert_data(const char *, const char *, char *, size_t);
+ char * safe_convert_data(const char *, const char *, char *, int *);
+
+
+ /* --- time --- */
+ char * char_wday(int);
+ char * char_mon(int);
+ int utime_getr(time_t, char);
+ int ctime_getr(char);
+ int time_minus(int, int, char);
+ int day_plasminus(int *, int *, int *, char);
+ int time_plas(int, int, char);
+ time_t get_unixtime(int, int, int, int, int, int);
+ int day_minus(int);
+ int month_last(int, int);
+ int month_minus(int);
+ char * time_getr(char *);
+ double gettimeofday_se(void);
+ char * message_id(char * backdata, char * name, char * domain);
+
+ /* --- socket --- */
+ int socket_bind46(struct addrinfo * hints, char * addr, char * port, int * ls, int maxsock);
+ char * socket_accept46(char * ipdate, fd_set rfd, int * s, int smax, int sockmax, int * sk, int * net);
+ int socket_accept46rfd(fd_set * rfd, int * s, int smax);
+ int socket_connect46(struct addrinfo * hints, char * ip, char * port, int * sk);
+ int socket_connect46select(struct addrinfo * hints, char * ip, char * port, int * sk, int timeout);
+
+ int socket_connect(struct sockaddr_in *, int, char [], int *);
+ int socket_bind(struct sockaddr_in *, int, char *, int *);
+ int socket_accept(struct sockaddr_in *, int *, int *);
+
+// int select_connect(int *, struct sockaddr_in *, int, int);
+ int select_connect(int *, struct sockaddr_in *, int);
+
+ /* --- thread --- */
+ #include<pthread.h>
+ int safe_pthread_mutex_lock(pthread_mutex_t *);
+
+ /* --- bit --- */
+ char * out_bit(unsigned int ina, char * bit, int bx);
+ unsigned long in_bit(char * bit, char bx);
+ int shift8_updown_in(int, int, int, int);
+ int shift8_updown_out(int, char);
+
+ // set backgroud process
+ void initdaemon(char *);
+
+
+#endif
+
+
--- /dev/null
+cmake_minimum_required (VERSION 2.6)
+
+project (libuutest)
+
+# add_library (uutest_lib SHARED libuutest.c)
+add_library (uutest_lib STATIC libuutest.c)
+
--- /dev/null
+/* libms */
+
+ LIBMS ライブラリー インストールガイド
+
+
+
+
+
--- /dev/null
+/*
+* 以下関数群は動的なメモリーの割り当てを前提にした、c言語のための標準的文字列操作の関数です。
+* 私が自分のプログラミングの為に書きました。
+* どなたでもご利用になれますし、書き換えも構いません。
+* この関数は私 Masashi Shimakuraが20051123に書きました、現在でもメンテナンスを行ってます。
+* 何かお気づきの点がありましたら以下にご連絡ください。
+* インストールされる場合は同封のINSTALL.utfjpファイルを確認してください。
+* 具体的な書き方はlibmstestのソースであるtest.cを確認する方法もあります。
+*
+* mail: masashi@ms-n.com
+* 2014/02/20 書き換えました
+*
+*/
+
+このFILEは libms.so ライブラリに含まれる以下の関数の使いかたを説明しています。
+
+ (以下は動的アロケーションの関数)
+ SAFE_FPCAT() ファイルポインターから一行読み込む
+ SAFE_FDCPM() ファイルディスクリプターから一行読み込む
+ SAFE_FDCAT() ファイルディスクリプターから改行まで読み込む
+ SAFE_FILEFDCAT() ファイルディスクリプターからストリーム終端まで読み込む
+ SAFE_MEMCPY() バッファーに任意のサイズの文字列をコピーする
+ SAFE_STRNCAT() 既に使われているバッファーの後ろに文字列を追加する
+ SAFE_SPRINTF() フォーマット文字列をバッファーにコピーする
+ DELIM_GET() デリミターで区切られたデータの指定番めを取り出す
+ DELIM_F() デリミターで区切られた文字列の先頭からX個分をコピーする
+ DELIM_R() デリミターで区切られた文字列のX個目から後ろをコピーする
+ ALGET_READ() fdから得たデータをネゴしながら行単位で受け取りファイルに書き出す関数。
+ ALGET_WRITE() FPから一行ずつ読み出したデータをネゴしながら一定量小分けでsendする関数
+ SWAP_RN() 文字列全体の中のすべての指定文字を、(\r\n)の改行に置き換える。
+ NULL_FREE() バッファーの使用された大きさ分だけNULLで埋める。
+
+ (以下は通常の関数)
+ SELF_MEMCPY() 指定サイズを越えないメモリーコピー
+ SELF_STRNCAT() 指定サイズを越えないでバッファーの後端に文字列を追加する
+ SELF_MEMCMP() お互いの大きさも考慮した文字列の比較
+ SELF_DELIM_GET() デリミターで区切られたデータの指定番めを取り出す、動的なバッファーを使わない
+
+ (以下はソケット関数)
+ SOCKET_READS() ファイルディスクリプタから動的なバッファに読み込む
+ SOCKET_READA() ファイルディスクリプタから動的なバッファに読み込む
+ SOCKET_READAS() ファイルディスクリプタから動的なバッファに読み込む (select付き)
+ SOCKET_READASTH() ファイルディスクリプタから動的なバッファに読み込む (readのtimeoutあり)
+ SOCKET_SENDS() ファイルディスクリプタに書き込む 1 (select)
+ SOCKET_SEND() ファイルディスクリプタに書き込む 2
+ SELECT_FDCAT() ファイルディスクリプタから読み込む
+
+ (以下はFILE操作関数)
+ FILE_COPY() ファイルのコピー
+ UNLINKDIR() ディレクトリー内のファイルの一括削除
+
+
+
+ (以下は低水準な関数)
+ CH_INT() 文字列が数字か+,-で構成されていることを確認
+ CH_INT2() 文字列が数字で構成されていることを確認
+ CH_FLOAT() 文字列が数字と'.'で構成されていることを確認
+ CH_INT3() 文字列が数字か任意の文字一つで構成されていることを確認
+ CH_INT4() 文字列が数字と任意の文字一つで構成されていることを確認
+ CH_INT_V6() dataがIPV6アドレスを構成する文字であることを確認
+ CH_INT_V4() dataがIPV4アドレスを構成する文字であることを確認
+ CH_CHAR() 文字列が数字かASCII文字であることを確認し、バッファーにコピーする。
+ CHAR_COUNT() 文字列に検索するキャラクタが幾つ含まれるか数える
+ CHAR_GET() 文字列をデリミターで区切り、指定番めの文字列をバッファに入れる。
+ CHAR_POINT() 文字列の中で指定文字が指定番めに表れる先頭からの位置を返す。
+ CLEAN_MEM() 文字列を指定した文字で全て書き換える。
+ COUNT_MEMCPY() 文字列の先頭から指定した数だけバッファにコピーする
+ COUNT_MEMCPY2() 文字列の指定位置から指定した数だけバッファにコピーする
+ DELIM_COUNT() 文字列をデリミターで区切り、指定番めの文字列の先頭位置と終端位置を返す
+ MEM_COUNT() 文字列に指定文字が最後に表れる場所（番め）を返す。
+ MEM_TCOUNT() 文字列に指定文字が最初に表れる場所（番め）を返す。
+ MEMCOUNT_CPM() 文字列の指定位置を別バッファにコピーする
+ RM_CRLF() 文字列の中の\r\nを0x00に置き換える
+ RM_CHAR() 文字列の中の特定の文字を消して、お尻をつめる。
+ SET_MEM() 文字列の中の特定の文字を0x00に置き換える
+ SWAP_MEM() 特定の文字を特定の文字で置き換える
+ SWAP_ARMEM() 特定の範囲の特定の文字を特定の文字で置き換える
+ CHMEM() とにかく指定した数だけ0x00でうめる。
+
+
+ (以下は特殊用途関数)
+ BASE64() 文字列をbase64エンコードする。
+ UJTOJ() EUC文字列をJISに変更する。
+ SAFE_BASE64() 文字列をbase64エンコードする。(動的バッファ)
+ SAFE_UJTOJ() EUC文字列をJISに変更する。（動的バッファ）
+ MIME_UJTOJ() EUC文字列をJISに変換しながら、76文字で折り返しMIMEに従ったsubject文字に変更する。（動的バッファ）
+ RANDDATA() 指定した数字の幅の中から、マイクロ秒をseedとして生成した乱数を返す。
+ COUNTS() 指定した幅の数を少ない方から順番に返す。
+ IN_BIT() '0101'で表現された文字列（2進数）を整数に変換する。
+ OUT_BIT() 整数を'01010'で表現される文字列（2進数）に変換する。
+ SHIFT8_UPDOWN_IN() 32Bit整数を8Bitで4っに分けてそれぞれに8Bitで表現可能な数を入れる
+ SHIFT8_UPDOWN_OUT() 32Bit整数を8Bitで4っに分けて、それぞれの値を別に取り出す。
+ INITDAEMON() 指定したコマンドを子プロセスにして、バックグランドに落す
+ INITDAEMONS() 自らのプロセスをバックグラウンドに落す
+ CONVERT() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。
+ SELF_CONVERT_DATA() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。文字数の制限つき。普通のバッファー用
+ SAFE_CONVERT_DATA() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。(動的バッファー)
+
+
+
+ (以下は時間関係の関数リファレンス)
+ CHAR_WDAY() 0から6の数字から3文字の曜日を示す文字列をかえす。
+ CHAR_MON() 0から11の数字から3文字の月を示す文字列をかえす。
+ UTIME_GETR() unix time からcharで指定した時間をかえす
+ CTIME_GETR() 現在時刻の指定文字の示す時間属性をかえす
+ TIME_MINUS() cha 単位で t 時 から mt 時間引いた時間を返す関数 0 - 1 = 23
+ TIME_PLAS() cha 単位で t 時 に mt 時間プラスした時間を返す関数 23 + 2 = 1
+ DAY_PLASMINUS() 一日前後の日、月、年を出す
+ GET_UNIXTIME() localな時間からUNIX時間をかえす。
+ DAY_MINUS() 現在の年月で、一日前の日をかえす。(1 - 1 = 31)
+ MONTH_LAST() 何年何月の最後の日を出す
+ MONTH_MINUS() 指定月から一ヶ月引いた月をかえす。単純。。
+ TIME_GETR() 現在時刻の:区切りの文字列をバッファにかえす。
+
+
+
+
+
+
+
+
+ ----- 以下は動的アロケーション関数リファレンス -----
+
+
+
+
+名前
+ SAFE_FPCAT() ファイルポインターから一行読み込む
+
+書式
+ char * safe_fpcat(FILE *(1), char *(2), int *(3), int(4));
+ (1) ファイルポインター
+ (2) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (3) 終了ステータス(int ポインター) 、異常は(-1)を返す。
+ (4) int 確保するバッファーの上限
+
+ 使用例 > data = safe_fpcat(fp, data, &stat, MAX_LEN);
+
+説明
+ ファイルポインターから一行バッファーに読み込み終了する関数。(動的バッファー)
+ 得られるバッファーの後端に改行を含まない。
+ バッファーのアドレスは変化するので戻り値(char *)を信用すること、通常の使用では(2)
+ と戻り値の変数は同じになる。
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+名前
+ SAFE_FDCPM() ファイルディスクリプターから一行読み込む
+
+書式
+ char * safe_fdcpm(int(1), char *(2), int *stat(3), int(4));
+ (1) int ファイルディスクプリター
+ (2) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (3) 終了ステータス(intポインター) 、異常は(-1)を返す。
+ (4) int 確保するバッファーの上限
+
+ 使用例 > data = safe_fdcpm(fd, data, &stat, MAX_LEN);
+
+説明
+ ファイルディスクプリターから改行まで読み込み終了する関数。(動的バッファー)
+ 得られるバッファーの後端に改行を含む。
+ 但し閾値を超えた場合はバッファーの後端に改行を含まないので、含まない場合はエラー
+ とするか再度読むように使うこと。 バッファーのアドレスは変化するので戻り値(char *)
+ を信用すること、通常の使用では(2)と戻り値の変数は同じになる。
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+
+名前
+ SAFE_FDCAT() ファイルディスクリプターから改行まで読み込む
+
+書式
+ char * safe_fdcat(int(1), char *(2), int *stat(3), int(4), int(5));
+ (1) int ファイルディスクプリター
+ (2) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (3) 終了ステータス(ポインター) 、異常は(-1)を返す。
+ (4) int 確保するバッファーの上限。
+ (5) int select()にてタイムアウトを見る際の時間(sec)
+
+ 使用例 > data = safe_fdcat(fd, data, &stat, MAX_LEN, time);
+
+説明
+ ファイルディスクプリターから改行まで読み込み終了する関数。(動的バッファー)
+ 得られるバッファーの後端に改行を含む。 但し閾値を超えた場合は改行のみを書き込
+ む。この場合得られるデータは改行のみとなる。問題のおきた場合のステータスは常に
+ -1 で、正常な場合は得たバイト数を返す。0の場合は正常である。
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+
+名前
+ SAFE_FILEFDCAT() ファイルディスクリプターからストリーム終端まで読み込む
+
+書式
+ char * safe_filefdcat(int(1), char *(2), int *stat(3), int(4), int(5));
+ (1) int ファイルディスクプリター
+ (2) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (3) 終了ステータス(ポインター) 、異常は(-1)を返す。
+ (4) int 確保するバッファーの上限。
+ (5) int select()にてタイムアウトを見る際の時間(sec)
+
+ 使用例 > data = safe_filefdcat(fd, data, indata, &stat, MAX_LEN);
+
+説明
+ ファイルディスクプリターからストリームの終端まで読み込み終了する関数。(動的バッファー)
+ 得られるバッファーの後端に改行を含む。 但し閾値を超えた場合はバッファーの後端に改行を
+ 書き込み、それ以後改行が読まれるまでfdを空読みする。 EOF(End of file)が読まれるまで
+ ループを抜けない点に注意。 バッファーのアドレスは変化するので戻り値(char *)を信用する
+ こと、通常の使用では(2)と戻り値の変数は同じになる。
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+名前
+ SAFE_MEMCPY() バッファーに任意のサイズの文字列をコピーする
+
+書式
+ char * safe_memcpy(char *(1), char *(2), int(3));
+ (1) char * char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (2) char * 読み込むバッファー。
+ (3) int 確保するバッファーの上限
+
+ 使用例 > data = safe_memcpy(data, indata, MAX_LEN);
+
+説明
+ バッファーからバッファーにデータをコピーする関数。(動的バッファー)
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+
+名前
+ SAFE_STRNCAT() 既に使われているバッファーの後ろに文字列を追加する
+
+書式
+ char * safe_strncat(char *(1), char *(2), int(3));
+ (1) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (2) char * 読み込むバッファー。
+ (3) int 確保するバッファーの上限
+
+ 使用例 > data = safe_strncat(data, indata, MAX_LEN);
+
+説明
+ すでにあるバッファーの大きさを変更して、すでに入っているデータの後ろにデータを追加
+ する関数。(動的バッファー)
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+
+名前
+ SAFE_SPRINTF() フォーマット文字列をバッファーにコピーする
+
+書式
+ char * safe_sprintf(char *(1), int(4), const char *(2), format, ...);
+ (1) char * すでにmalloc()で確保されたバッファーを指定（通常戻り値も同じになる）
+ (2) フォーマット文字列 " taro %d?n"
+ (3) フォーマット用変数、データ(数は10個まで)
+ (4) int 確保するバッファーの上限
+
+ 使用例 > data = safe_sprintf(data, MAX_LEN, "--%d--?n", inA);
+
+説明
+ フォーマット文字列から指定したバッファーにデータを追加する関数。(動的バッファー)
+ 読み込みバッファーを指定して書き込むことは出来ませんので注意。
+
+返り値
+ 動的にサイズを調整(mallc)したバッファのアドレスを返す。失敗した場合はNULLを返す。
+
+
+
+
+
+
+名前
+ DELIM_GET() デリミターで区切られたデータの指定番めを取り出す
+
+書式
+ char * delim_get(char *(1), char *(2), char(3), int *(4), int(5));
+ (1) char * 元データ
+ (2) char * 取り出したデータを入れるバファ
+ (3) デリミター
+ (4) ステータス、異常は-1
+ (5) 何番めかの指定
+
+ 使用例 > data = delim_get(base, data, ',', %stat, 4);
+
+説明
+ 上の使用例ではbase内をデリミタ(,)で区切った場合の4番めの文字列をdataに
+ 書き込む。書き込むバッファは予めmalloc()されている必要がある。
+
+帰り値
+ 失敗した場合は返却文字列に"NOT"を書き込む。
+ 終端には0x00が入る。
+
+
+
+
+
+名前
+ DELIM_F() デリミターで区切られた文字列の先頭からX個分をコピーする
+
+書式
+ char * delim_f(char *(1), char * (2), char(3), int(4));
+ (1) char * 元データ
+ (2) char * 取り出したデータを入れるバファ
+ (3) デリミター
+ (4) 何番めかの指定
+
+ 使用例 > data = delim_f(base, data, ',', 4);
+
+説明
+ 上記の例だと、base を区切る','の4個めまでの文字列をdataにコピーする。
+ 最後にデリミターを追加することに注意
+
+帰り値
+ 文字列のポインターを返す
+
+
+
+
+名前
+ DELIM_R() デリミターで区切られた文字列のX個目から後ろをコピーする
+
+書式
+ char * delim_r(char *(1), char * (2), char(3), int(4));
+ (1) char * 元データ
+ (2) char * 取り出したデータを入れるバファ
+ (3) デリミター
+ (4) 何番めかの指定
+
+ 使用例 > data = delim_r(base, data, ',', 4);
+
+説明
+ 上記の例だと、base を区切る','の4個めから後ろの文字列をdataにコピーする。
+ 最後にデリミターを追加しないことに注意
+
+帰り値
+ 文字列のポインターを返す
+
+
+
+
+
+
+
+
+ ----- 以下は通常関数のリファレンス -----
+
+
+
+
+名前
+ SELF_MEMCPY() 指定サイズを越えないメモリーコピー
+
+書式
+ int self_memcpy(char *(1), char *(2), int(3));
+ (1) char * コピー先のバッファ
+ (2) char * コピー元のバッファ
+ (3) int コピーする文字列の上限、普通は(1)で確保されている上限サイズ
+
+ 使用例 > ret = self_memcpy(data, "ABCD", 128);
+
+説明
+ 大きさが固定のバッファーに対して、安全にデータをコピーする。
+
+返り値
+ つねに0を返す
+
+
+
+
+
+名前
+ SELF_STRNCAT() 指定サイズを越えないでバッファーの後端に文字列を追加する
+
+書式
+ int self_strncat(char *(1), char *(2), int(3));
+ (1) char * コピー先のバッファ
+ (2) char * コピー元のバッファ
+ (3) int コピーする文字列の上限、普通は(1)で確保されている上限サイズ
+
+ 使用例 > ret = self_memcpy(data, "ABCD", 128);
+
+説明
+ 大きさが固定のバッファーに対して、安全にデータを後端にコピーする。
+
+返り値
+ つねに0を返す
+
+
+
+
+
+名前
+ SELF_MEMCMP() お互いの大きさも考慮した文字列の比較
+
+書式
+ int self_memcmp(char *(1), char *(2));
+ (1) char * 比較文字列1
+ (2) char * 比較文字列2
+
+ 使用例 > ret = self_memcmp(data1, "taro");
+
+説明
+ 文字列同士の比較だが、サイズが違う場合もエラーと判断する。
+
+返り値
+ 通常のmemcmp()と同じだが、サイズが違う場合も-1を返す。
+
+
+
+
+
+
+名前
+ ALGET_READ() fdから得たデータをネゴしながら行単位で受け取りファイルに書き出す関数。
+
+書式
+ char * alget_read(char *(1), int(2), int(3), int(4), int *(5), char(6), int(7), int(8));
+ (1) 書き出すファイルのパス名前
+ (2) データを置くバファ（意味ないので、いずれなくします）
+ (3) ファイルディスクリプター
+ (4) 返却ステータスのポインター
+ (5) 受け取りデータの特定の文字を置き換えます。（普通は送信時に改行を何に変えているか)
+ (6) この数字よりサイズが大きいとデータの受け取りを一時中断しますが、実際の単位は行単位です。
+ (7) mode 1 client -> server 最後にステータスを送る
+ mode 0 server -> client 受け取って終わり
+
+使用例
+ rec = alget_read(filename, rec, sk, interval, &stat, delim, file_len, mode);
+
+返り値
+ (2)のポインターを返すが、現状で意味がないので、いずれへんこうします。
+
+
+
+
+名前
+ ALGET_WRITE() FPから一行ずつ読み出したデータをネゴしながら一定量小分けでsendする関数
+
+書式
+ int alget_write(int(1), FILE *(2), int(3), char(4), int(5), int(6));
+ (1) ファイルディスクリプター
+ (2) 書き出すファイルのファイルポインター
+ (3) select()の待ち時間(秒)
+ (4) 送信データの特定の文字を置き換えます。（普通は送信時に改行を何に変えるか)
+ (5) この数字よりサイズが大きいとデータの受け取りを一時中断しますが、実際の単位は行単位です。
+ (6) mode 1 client -> server 最後にステータスを送る
+ mode 0 server -> client 受け取って終わり
+
+使用例
+ ren = alget_write(int sock_fd, FILE * fp, int interval, char delim, int file_len, int mode);
+
+返り値
+ エラーの場合は-1を返します。
+
+
+
+
+名前
+ SWAP_RN() 文字列全体の中のすべての指定文字を、(\r\n)の改行に置き換える。
+
+書式
+ char * swap_rn(char *(1), char(2));
+ (1) 文字列のポインター、予め動的に確保されたものであること。
+ (2) 置き換える文字。
+
+ 使用例 ＞ data = swap_rn(data, 'a');
+
+返り値
+ 通常は（1）を加工し、そのポインターを返します。
+
+
+
+
+名前
+ NULL_FREE() バッファーの使用された大きさ分だけNULLで埋める。
+
+書式
+ char * null_free(char *(1));
+ (1) NULLで埋めたいバッファのポインター
+
+ 使用例 ＞ data = null_free(data);
+
+返り値
+ ポインターを返す
+
+
+
+
+名前
+ SELF_DELIM_GET() デリミターで区切られたデータの指定番めを取り出す、 固定バッファ用
+
+書式
+ int self_delim_get(char *(1), char *(2), char(3), int(4), int(5))
+ (1) char * 元データ
+ (2) char * 取り出したデータを入れるバファ（固定長）
+ (3) デリミター
+ (4) 何番めかの指定
+ (5) 2バッファーの大きさ
+
+ 使用例 > memset(data, 0x00, 1024);
+ ret = self_delim_get(base, data, ',', 4, 1024);
+
+説明
+ 上の使用例ではbase内をデリミタ(,)で区切った場合の4番めの文字列をdataに
+ 書き込む。書き込むバッファは固定長であり、充分な大きさを持つこと。
+
+帰り値
+ 失敗した場合は-1を返す。
+ 終端には0x00が入る。
+
+
+
+
+
+
+
+
+
+ ----- 以下はソケット関係の関数リファレンス -----
+
+
+
+名前
+ SOCKET_READA() ファイルディスクリプタから動的なバッファに読み込む
+
+書式
+ int socket_reada(int(1), char *(2), int max);
+ (1) int ファイルディスクリプタ番号
+ (2) char * 受け取ったデータを格納するバッファ
+ (3) バッファの最大数
+
+ 使用例 > ret = socket_reada(sk, readdata, max);
+
+説明
+ 戻り値が0の場合に読み込んだバファの終端が改行である場合に終了。
+
+返り値
+ 読み込んだバッファーのサイズを返す、失敗した場合は-1を返す。
+ バッファーの溢れなどは確認しない。
+
+
+
+
+
+
+名前
+ SOCKET_READAS() ファイルディスクリプタから動的なバッファに読み込む (select付き)
+
+書式
+ int socket_readas(int(1), char *(2), int max, int interval, int mode);
+ (1) int ファイルディスクリプタ番号
+ (2) char * 受け取ったデータを格納するバッファ
+ (3) バッファの最大数
+ (4) select time out 秒
+ (5) 終了モード
+
+ 使用例 > ret = socket_reada(sk, readdata, max, interval, 0);
+
+説明
+ ただやみくもにread()と使うのなら、こちら使ってください。
+ readごとにselectでfdを確認している
+ mode 1 は終端に改行が有る場合に終了、それ以外は0x0d,0x0aがある場合に終了。
+ intervalは上の条件を満たさずに、FDが次のデータを返さない場合の待ち時間。
+
+返り値
+ 読み込んだバッファーのサイズを返す、失敗した場合は-1を返す。
+ バッファーの溢れなどは確認しない。
+
+
+
+
+
+名前
+ SOCKET_READASTH() ファイルディスクリプタから動的なバッファに読み込む (readのtimeoutあり)
+
+書式
+ int socket_readasth(int(1), char *(2), int max, int interval, int mode);
+ (1) int ファイルディスクリプタ番号
+ (2) char * 受け取ったデータを格納するバッファ
+ (3) バッファの最大数
+ (4) select time out 秒
+ (5) 終了モード
+
+ 使用例 > ret = socket_readath(sk, readdata, max, interval, 0);
+
+説明
+ ただやみくもにread()を使うのなら、こちら使ってください。
+ readごとにselectでfdを確認している
+ 複数回のread()のトータルの時間をtimeoutさせます。
+ mode 1 は終端に改行が有る場合に終了、それ以外は0x0d,0x0aがある場合に終了。
+ intervalは上の条件を満たさずに、FDが次のデータを返さない場合の待ち時間。
+ read()のtimeoutにpthreadを使っています。
+ スレッドの中で実行するなど同時に沢山実行する場合はスタックのサイズに注意してください。
+
+返り値
+ 読み込んだバッファーのサイズを返す、失敗した場合は-1を返す。
+ read()じたいで時間超過した場合は-2を返します。
+
+
+
+
+
+名前
+ SOCKET_READS() ファイルディスクリプタから動的なバッファに読み込む
+
+書式
+ int socket_reads(int(1), char *(2), int(3), int(4));
+ (1) int ファイルディスクリプタ番号
+ (2) char * 受け取ったデータを格納するバッファ（動的バッファ）
+ (3) int 受け取るデータサイズの上限
+ (4) int ファイルディスクリプタの変化を待つ時間 (sec)
+
+ 使用例 > ret = socket_reads(sk, readdata, getlen, interval);
+
+説明
+ ファイルディスクリプタが変化するのを指定時間待ち、タイムアウトする。
+ 変化があり、読み込めた場合は動的なサイズのバッファにデータを書き込む。
+
+返り値
+ 読み込んだバッファーのサイズを返す、失敗した場合やタイムアウトした場合
+ は-1を返す。
+
+
+
+
+
+名前
+ SOCKET_SENDS() ファイルディスクリプタに書き込む
+
+書式
+ int socket_sends(int(1), char *(2), int(3), char(4));
+ (1) int ファイルディスクリプタ番号
+ (2) char * 書き込むデータの入ったバッファ
+ (3) int ファイルディスクリプタの変化を待つ時間 (sec)
+ (4) char 通常は0 サーバ側で使う場合は 1 を指定
+
+ 使用例 > ret = socket_sends(sk, senddata, 5, 0);
+
+説明
+ ファイルディスクリプタに書き込み可能になるのを待って書き込む。
+
+返り値
+ 書き込んだバッファーのサイズを返す。失敗した場合やタイムアウトの場合は
+ -1を返す。
+
+
+
+
+
+名前
+ SOCKET_SEND() ファイルディスクリプタに書き込む
+
+書式
+ int socket_sends(int(1), char *(2), int(3));
+ (1) int ファイルディスクリプタ番号
+ (2) char * 書き込むデータの入ったバッファ
+ (3) int ファイルディスクリプタの変化を待つ時間 (sec)
+
+ 使用例 > ret = socket_sends(sk, senddata, 5);
+
+説明
+ ファイルディスクリプタに書き込み可能になるのを待って書き込む。
+
+返り値
+ 書き込んだバッファーのサイズを返す。失敗した場合やタイムアウトの場合は
+ -1を返す。
+
+
+
+
+
+名前
+ SELECT_FDCAT() ファイルディスクリプタから読み出しバファに格納
+
+書式
+ char * select_fdcat(int(1), char *(2), int *(3), int(4), int(5))
+ (1) int ファイルディスクリプタ番号
+ (2) char * 書き込むデータの入ったバッファ
+ (3) 返却ステータスのポインターを指定する。
+ (4) バファに格納する上限サイズ
+ (5) select()の待ち時間(秒)
+
+ 使用例 > data = socket_sends(sk, data, &ret, MAX, interval);
+
+返り値
+ 読み出したデータを返す。
+
+
+
+
+
+
+ ----- 以下はファイル操作関数リファレンス ----
+
+名前
+ FILE_COPY() ファイルをコピーする
+
+書式
+ int file_copy(char *(1), char *(2));
+ (1) char * 読み込むファイル名
+ (2) char * 書き込むファイル名
+
+ 使用例 > ret = file_copy("/tmp/a.txt", "/tmp/b.txt");
+
+説明
+ 読み込みファイルから読み込み、その内容をそのまま書き込みファイルにうつす。
+
+返り値
+ 失敗した場合は -1 を返す。成功した場合はコピーしたバイト数を返す。
+
+
+
+
+名前
+ UNLINKDIR() ディレクトリー内のファイルの一括削除
+
+書式
+ int unlinkdir(char *(1));
+ (1) char * ディレクトリ名
+
+ 使用例 > ret = unlinkdir("/tmp/");
+
+説明
+ ディレクトリをオープンし、中に含まれるファイルをすべて消す。
+
+返り値
+ 失敗した場合（ディレクトリが開けない場合）は-1、または開けても削除に失敗し
+ たファイル数の分だけ-1していく。
+
+
+
+
+
+
+ ----- 以下は低水準関数リファレンス -----
+
+
+
+名前
+ CH_INT() 文字列が数字か+,-で構成されていることを確認
+
+書式
+ int ch_int(char *(1));
+ (1) チェックするバッファ
+
+ 使用例 > ret = ch_int(data);
+
+説明
+ 単純に、data 内に数字か正負記号以外が含まれた場合は-1を返し、無い場合は0を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CH_INT2() 文字列が数字で構成されていることを確認
+
+書式
+ int ch_int2(char *(1));
+ (1) チェックするバッファ
+
+ 使用例 > ret = ch_int2(data);
+
+説明
+ 単純に、data 内に数字以外が含まれた場合は-1を返し、無い場合は0を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CH_FLOAT() 文字列が数字と'.'で構成されていることを確認
+
+書式
+ int ch_float(char *(1));
+ (1) チェックするバッファ
+
+ 使用例 > ret = ch_float(data);
+
+説明
+ 単純に、data 内に数字と'.'以外が含まれた場合は-1を返し、無い場合は0を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CH_INT3() 文字列が数字か任意の文字一つで構成されていることを確認
+
+書式
+ int ch_int3(char *(1), char(2));
+ (1) チェックするバッファ
+ (2) 文字
+
+ 使用例 > ret = ch_int3(data, ':');
+
+説明
+ 単純に、data 内がすべて数字の場合と、中に任意の文字が含まれた場合は0、それ以外は-1を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+名前
+ CH_INT4() 文字列が数字と任意の文字一つで構成されていることを確認
+
+書式
+ int ch_int4(char *(1), char(2));
+ (1) チェックするバッファ
+ (2) 文字
+
+ 使用例 > ret = ch_int4(data, ':');
+
+説明
+ 単純に、data 内が数字と、任意の文字一文字で構成された場合は0、それ以外は-1を返す。
+ 数字だけでも、任意の文字だけでも駄目で、両方だけで構成されること。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CH_INT_V6() dataがIPV6アドレスを構成する文字であることを確認
+
+書式
+ int ch_int_v6(char *(1));
+ (1) チェックするバッファ
+
+ 使用例 > ret = ch_int_v6(data);
+
+説明
+ 単純に、data 内にIPV6アドレスを構成する以外の文字が含まれた場合は-1を返し、無い場合
+ は0を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+
+
+名前
+ CH_INT_V4() dataがIPV4アドレスを構成する文字であることを確認
+
+書式
+ int ch_int_v4(char *(1));
+ (1) チェックするバッファ
+
+ 使用例 > ret = ch_int_v4(data);
+
+説明
+ 単純に、data 内にIPV4アドレスを構成する以外の文字が含まれた場合は-1を返し、無い場合
+ は0を返す。
+
+返り値
+ 説明に従う
+
+
+
+
+
+
+
+名前
+ CH_CHAR() 文字列が数字かASCII文字であることを確認し、バッファーにコピーする。
+
+書式
+ int ch_char(char *(1), char *(2));
+ (1) チェックするバッファ
+ (2) コピー先バッファ
+
+使用例 > ret = ch_char(data, cpydata);
+
+説明
+ 1の中に含まれる数字とASCII文字だけを2のバッファーにコピーする。
+ 終端に0x00を書き込む。2のバッファの大きさの確認はしないので注意。
+
+返り値
+ コピーした数を返す。一つの移らない場合は0を返す。1、2が同じなら全てコピーしたことになる。
+
+
+
+
+名前
+ CHAR_COUNT() 文字列に検索するキャラクタが幾つ含まれるか数える
+
+書式
+ int char_count(char *(1), char(2));
+ (1) char * 検索される文字列
+ (2) char 検索文字
+
+ 使用例 > ret = char_count("123-567", '-');
+
+説明
+ 例の場合、'123-567'の中に'-'が一つあるのでret=1になる。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CHAR_GET() 文字列をデリミターで区切り、指定番めの文字列をバッファに入れる。
+
+書式
+ int char_get(char[](1), char[](2), char(3), int(4));
+ (1) char[] 検索される文字列
+ (2) char[] 取り出されたデータを入れるバッファ。サイズチェックが無いので注意。
+ (3) デリミター文字
+ (4) デリミターの位置番め
+
+ 使用例 > ret = char_get("-123-456-789-", buf, '-', 2);
+
+説明
+ 例の場合、文字列に'-'が表れる2番めから3番めまでの文字列'456'がbufに格納される。
+ 終端には0x00が入る。
+
+返り値
+ 返す文字列のサイズを返す。
+
+
+
+
+
+名前
+ CHAR_POINT() 文字列の中で指定文字が指定番めに表れる先頭からの位置を返す。
+
+書式
+ int char_point(char *(1), char(2), int(3));
+ (1) char * 検索文字列
+ (2) char 検索文字
+ (3) int 検索文字の位置（番め）
+
+ 使用例 > ret = char_point("-12-345-6789-", '-', 3);
+
+説明
+ 例の場合、文字列に'-'が3番めに表れる先頭からの位置は7なので7を返す。
+ 但し、先頭文字を0番めとして数えているので注意。
+
+返り値
+ 説明に従う
+
+
+
+
+
+名前
+ CLEAN_MEM() 文字列を指定した文字で全て書き換える。
+
+書式
+ int clean_mem(char[](1), char(2), int(3));
+ (1) char[] 書き換えるバッファ
+ (2) char 書き換える文字
+ (3) バッファのサイズ
+
+ 使用例 > ret = clean_mem(buf, (char)0x00, (int)strlen(buf));
+
+説明
+ 例の場合、bufの中を全てNULL文字でうめる。
+ 後端から埋めていくことに注意。
+
+返り値
+ 成功した場合は0を返す。
+
+
+
+
+
+
+名前
+ COUNT_MEMCPY() 文字列の先頭から指定した数だけバッファにコピーする
+
+書式
+ int count_memcpy(char[](1), char[](2), int(3));
+ (1) char[] コピー先のバッファ、サイズチェックなしなので注意
+ (2) char[] コピー元のバッファ
+ (3) int (2)の先頭からコピーするバイト数
+
+ 使用例 > ret = count_memcpy(buf, "1234567", 3);
+
+説明
+ 例の場合、bufには123の文字列がコピーされる、終端は0x00で埋められる。
+
+返り値
+ 書き込んだバイト数を返す。
+
+
+
+
+
+
+名前
+ COUNT_MEMCPY2() 文字列の指定位置から指定した数だけバッファにコピーする
+
+書式
+ int count_memcpy(char[](1), char[](2), int(3));
+ (1) char[] コピー先のバッファ、サイズチェックなしなので注意
+ (2) char[] コピー元のバッファ
+ (3) int 指定位置(先頭からのバイト数)
+ (4) int (3)の位置からコピーするバイト数
+
+ 使用例 > ret = count_memcpy2(buf, "1234567", 3, 6);
+
+説明
+ 例の場合、bufには3456の文字列がコピーされる、終端は0x00で埋められる。
+
+返り値
+ 書き込んだバイト数を返す。
+
+
+
+
+
+
+
+
+名前
+ DELIM_COUNT() 文字列をデリミターで区切り、指定番めの文字列の先頭位置と終端位置を返す。
+
+書式
+ int delim_count(char *(1), char(2), int(3), int *(4), int *(5));
+ (1) char * 分割される文字列
+ (2) char デリミター文字
+ (3) int デリミターの位置番め
+ (4) int * 切り出した文字列の先頭位置を返す、ポインター
+ (5) int * 切り出した文字列の終端位置を返す、ポインター
+
+ 使用例 > ret = delim_count("1-23-456-789", '-', 2, &sta, &sto);
+
+説明
+ 例の場合、'-'デリミタで2こ目の文字列は456になるが、この先頭位置を終端いちを
+ それぞれ&sta, &stoに返す。
+
+返り値
+ 失敗した場合は-1を返す。
+
+
+
+
+
+
+名前
+ MEM_COUNT() 文字列に指定文字が最後に表れる場所（番め）を返す。
+
+書式
+ int mem_count(char *(1), char(2));
+ (1) char * 検索文字列
+ (2) char 検索文字
+
+ 使用例 > ret = mem_count("12-345-678", '-');
+
+説明
+ 例の場合、'-'が最後に表れるのは先頭から6番めで、先頭を0とする。
+
+帰り値
+ 説明に従う
+
+
+
+
+
+名前
+ MEM_TCOUNT() 文字列に指定文字が最初に表れる場所（番め）を返す。
+
+書式
+ int mem_tcount(char *(1), char(2));
+ (1) char * 検索文字列
+ (2) char 検索文字
+
+ 使用例 > ret = mem_tcount("12-345-678", '-');
+
+説明
+ 例の場合、'-'が最初に表れるのは先頭から2番めで、先頭を0とする。
+
+帰り値
+ 説明に従う
+
+
+
+
+
+
+名前
+ MEMCOUNT_CPM() 文字列の指定位置を別バッファにコピーする
+
+書式
+ int memcount_cpm(char *(1), char *(2), int(3), int(4), int(5));
+ (1) char * コピー先のバッファ。サイズ確認なしなので注意
+ (2) char * 切り出す文字列
+ (3) int 切り出す先頭位置
+ (4) int 切り出す終端位置
+ (5) 1の大きさ
+
+ 使用例 > ret = memcount_cpm(buf, "0123456789", 3, 5, 8);
+
+説明
+ 例の場合、先頭を0と数えるので、bufに入るのは345です。
+
+返り値
+ 成功した場合はコピーした文字の数。
+ 失敗した場合は-1を返します。
+
+
+
+
+
+
+名前
+ RM_CRLF() 文字列の中の\r\nを0x00に置き換える
+
+書式
+ int rm_crlf(char *(1), int(2));
+ (1) char * データ文字列
+ (2) int 上限値、通常は strlen()の値
+
+ 使用例 > int = rm_crlf(data, (int)strlen(data));
+
+説明
+ 単純に改行コードをNULLに書き換えるので、文字列の途中にある場合は
+ データが切断されることに注意。
+
+返り値
+ データの大きさを返します。
+
+
+
+
+
+名前
+ RM_CHAR() 文字列の中の特定の文字を消して、お尻をつめる。
+
+書式
+ int rm_char(char *(1), char(2));
+ (1) char * データ文字列
+ (2) char 置き換え文字
+
+ 使用例 > ret = rm_char(data, 'd');
+
+説明
+ 文字列の中に現れる指定文字を消して、後ろからその位置に詰める。
+ 終端には0x00が入る。
+
+返り値
+ 消した文字数を返す。但しバッファーの中身が無くなった場合は0を返す。
+
+
+
+
+
+
+名前
+ SET_MEM() 文字列の中の特定の文字を0x00に置き換える
+
+書式
+ int set_mem(char *(1), char(2), int(3));
+ (1) char * データ文字列
+ (2) char 置き換え文字
+ (3) int 上限値、通常はstrlen()の値
+
+ 使用例 > ret = set_mem(data, 'd', (int)strlen(data));
+
+説明
+ 特定の文字を0x00に置き換える。文字列の途中に指定文字があると、
+ データはそこで切断されるので注意。
+
+返り値
+ データの大きさを返す。
+
+
+
+
+
+
+名前
+ SWAP_MEM() 特定の文字を特定の文字で置き換える
+
+書式
+ int swap_mem(char *(1), char(2), char(3));
+ (1) char * 置き換え元の文字列
+ (2) char 置き換えられる文字
+ (3) char 置き換える文字
+
+ 使用例 > ret = swap_mem(data, 'x', 'g');
+
+説明
+ 例の場合、data の中の'x'を全て 'g'に置き換える。
+
+返り値
+ 置き換えた数を返します。
+
+
+
+
+
+
+名前
+ SWAP_ARMEM() 特定の範囲の特定の文字を特定の文字で置き換える
+
+書式
+ int swap_armem(char *(1), char(2), char(3), int(4), int(5));
+ (1) char * 置き換え元の文字列
+ (2) char 置き換えられる文字
+ (3) char 置き換える文字
+ (4) int 置き換える先頭文字
+ (5) int 置き換える終端文字
+
+ 使用例 > ret = swap_mem(data, 'x', 'g');
+
+説明
+ 例の場合、data の中の'x'を全て 'g'に置き換える。
+
+返り値
+ 置き換えた数を返します。
+
+
+
+
+
+名前
+ CHMEM() とにかく指定した数だけ0x00でうめる。
+
+書式
+ int chmem(char *(1), int);
+ (1) char * 置き換え元の文字列
+ (2) 置き換える文字数。
+
+ 使用例 > ret = chmem(data, 10);
+
+説明
+ とにかく指定した数だけ0x00でうめる。バッファの溢れは考慮しない。
+
+返り値
+ 2に対して、0より少ない数を指定すると-1を返す。
+
+
+
+
+
+
+
+
+ ----- 以下は特殊用途関数 -----
+
+名前
+ BASE64() 文字列をbase64エンコードする。
+
+書式
+ int base64(char[](1), int(2), char[](3));
+ (1) エンコード前の文字列
+ (2) エンコード前の文字列の大きさ
+ (3) エンコード後の文字列の入れ先
+
+ 使用例 ＞ base64(a, (int)strlen(a), b);
+
+説明
+ 上の場合aを64エンコードしてbに入れる。bの大きさは最低でもaの倍ないといけない。
+
+返り値
+ 現状で0しか返さない。
+
+
+
+
+
+名前
+ UJTOJ() EUC文字列をJISに変更する。
+
+書式
+ int ujtoj(unsigned char *(1), unsigned char *(2));
+ (1) 戻りバファ、JISに変換後。
+ (2) EUCのバファ。
+
+
+ 使用例 ＞ ujtoj((unsigned char *)out, (unsigned char *)in);
+
+説明
+ 上の場合in(EUC)をout(JIS)に変換します。
+ この関数は 「TCP_IP ネットワークプログラミング」から使わせていただいてます。
+
+返り値
+ 現状で0しか返さない。
+
+
+
+
+
+名前
+ SAFE_BASE64() 文字列をbase64エンコードする。 (動的バッファ)
+
+書式
+ char * safe_base64(char *(1));
+ (1) エンコードしたいバッファ。領域を予め動的に確保していること。
+
+ 使用例 ＞ data = safe_base64(data);
+
+説明
+ 予め動的に確保されたバッファにエンコードしたい文字列を入れsafe_base64()に渡すと、
+ 同じバッファにbase64エンコードされた文字列を返します。
+ このバッファは最大で渡した文字列の倍のサイズに動的に拡張されることに注意。
+
+返り値
+ バッファのポインターを返します。
+
+
+
+
+
+
+名前
+ SAFE_UJTOJ() EUC文字列をJISに変更する。(動的バッファ)
+
+書式
+ char * safe_ujtoj(char *(1));
+ (1) 変換したいバファ、(EUC をJISに変換)
+
+ 使用例 ＞ data = safe_ujtoj(data);
+
+説明
+ 上の場合data (EUC)をdata(JIS)に変換します。
+
+返り値
+ バッファのポインターを返します。
+
+
+
+
+
+
+名前
+ MIME_UJTOJ() EUC文字列をJISに変換しながら、76文字で折り返しMIMEに従ったsubject文字に変更する。（動的バッファ）
+
+書式
+ char * mime_ujtoj(char *(1));
+ (1) EUC文字列バッファ。領域を予め動的に確保していること。
+
+ 使用例 ＞ data = mime_ujtoj(data);
+
+説明
+ 上記の場合、EUC文字列をJISに変換しながら、76文字で折り返しMIMEに従ったsubject文字に変更した値を返す。
+
+返り値
+ バッファのポインターを返します。
+
+
+
+
+
+名前
+ RANDDATA() 指定した数字の幅の中から、マイクロ秒をseedとして生成した乱数を返す。
+
+書式
+ int randdata(int (1), int (2));
+ (1) 生成する乱数の下限
+ (2) 生成するランスの上限
+
+ 使用例 ＞ randint = randdata(0, 10);
+
+説明
+ 上記の場合、0から10の間の数字のいずれかをマイクロ秒を種として出した乱数の値で返す。
+
+返り値
+ 乱数を返す。
+
+
+
+
+名前
+ COUNTS() 指定した幅の数を少ない方から順番に返す。
+
+書式
+ int counts(char * (1), int (2), int(3));
+ (1) 数を書くファイル名(デフォルトでは/tmp/taro)
+ (2) 数の下限
+ (3) 数の上限
+
+ 使用例 ＞ back = counts("/tmp/hage", 0, 10);
+
+説明
+ 上記の場合、0から10の間の数字のいずれかを少ない方から順番に返す。
+ (1)は数を書き込んでおくファイルです。
+
+返り値
+ 数を返す。
+
+
+
+
+名前
+ IN_BIT() '0101'で表現された文字列（2進数）を整数に変換する。
+
+書式
+ unsigend long in_bit(char *(1), int(2));
+ (1) '01010'で表現された文字列（2進数）
+ (2) 文字列の幅（8文字なら8）
+
+ 使用例
+ unsigned int in8;
+ memset(ch8, 0x00, 34);
+ in8 = in_bit("01010101", 8);
+ ch8 = out_bit(in8, ch8, 8);
+ printf("in_bit() out_bit(): <%d><%s><%d>\n", in8, ch8, (int)in_bit(ch8, 8));
+
+説明
+ 上記の場合は'01010101'の文字列をin_Bit()にてin8に整数で与えている。
+
+返り値
+ 整数を返す、文字列の幅と実際の文字列の長さが異なる場合は-1を返す。
+ 与えた文字列に0、1意外が含まれる場合は-2を返す。
+
+
+
+
+名前
+ OUT_BIT() 整数を'01010'で表現される文字列（2進数）に変換する。
+
+書式
+ char * out_bit(unsigned int(1), char *(2), int(3));
+ (1) 文字列（2進数）に変換したい整数
+ (2) 文字列を納めるバッファのポインター
+ (3) 変換したい文字の幅
+
+ 使用例
+ unsigned int in8;
+ memset(ch8, 0x00, 34);
+ in8 = in_bit("01010101", 8);
+ ch8 = out_bit(in8, ch8, 8);
+ printf("in_bit() out_bit(): <%d><%s><%d>\n", in8, ch8, (int)in_bit(ch8, 8));
+
+説明
+ 上記の場合は一旦整数として格納した'01010101'を再度文字列に戻している。
+
+返り値
+ 格納した文字列のポインターを返す。
+
+
+
+
+名前
+ SHIFT8_UPDOWN_IN() 32Bit整数を8Bitで4っに分けてそれぞれに8Bitで表現可能な数を入れる
+
+書式
+ int = shift8_updown_in(int(1), int(2), int(3), int(4));
+ (1) 24〜32ビットまでに入る8ビットで表現可能な数字
+ (2) 16〜24ビットまでに入る8ビットで表現可能な数字
+ (3) 8〜16ビットまでに入る8ビットで表現可能な数字
+ (4) 0〜8ビットまでに入る8ビットで表現可能な数字
+
+ 使用例
+
+ int da = shift8_updown_in(255, 0, 0, 255);
+
+説明
+ 上の場合、下位8ビットに255を入れた
+
+返り値
+ 上の場合、32ビットの整数で255を返す
+
+
+
+
+
+名前
+ SHIFT8_UPDOWN_OUT() 32Bit整数を8Bitで4っに分けて、それぞれの値を別に取り出す。
+
+書式
+ int = shift8_updown_out(int(1), char(2));
+ (1) shift8_updown_in()で作った整数
+ (2) 取り出す位置を示す文字
+
+ 使用例
+ int da = shift8_updown_out(shift8_updown_in(0,0,0,255), 'd');
+
+説明
+ 上の場合、255を返す
+ 'd'は下位8ビット、'u'は8〜16、'm'は16〜24、't'は24〜32までに区切って返す。
+ つまりintの整数に8ビットまでの4っの意味を持たすことが出来ます。
+
+返り値
+ 上の場合、32ビットの整数で255を返す
+ 255までの整数なら、shift8_updown_out()を使う必要がない。
+
+
+
+
+
+名前
+ INITDAEMON() 自分自身をバックグランドに落し、引数の場所にchdir()する
+
+書式
+ void initdaemon(char *);
+
+ 使用例
+ initdaemon();
+
+説明
+ 自分自身をバックグランドに落し、引数の場所にchdir()する
+
+返り値
+ なし
+
+
+
+
+
+名前
+ INITDAEMONS() 自分自身をバックグランドに落す
+
+書式
+ void initdaemon(char *);
+
+ 使用例
+ initdaemon();
+
+説明
+ 自分自身をバックグランドに落す
+
+返り値
+ なし
+
+
+
+
+
+
+名前
+ CONVERT() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。
+
+書式
+ char * convert(const char *, const char *, const char *, char *, size_t, int *);
+
+ 使用例
+ output_data = convert("UTF-8", "ISO-2002-JP", input_data, output_data, 5042, &ret);
+
+説明
+ 上記の例だと、3番めの引数にあたる(input_data)に入れた文字列をUTF-8と断定して、
+ その文字列をISO-2002-JPに書き換え、(output_data）に戻す。
+ (output_data)の大きさは5024を越えない。
+ retのポインターは成功は0<、失敗は-*を返します。
+
+返り値
+ 戻り値はoutput_dataのポインターを返す。
+
+
+
+
+
+名前
+ SELF_CONVERT_DATA() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。文字数の制限つき。普通のバッファー用
+
+書式
+ int self_convert_data(const char *, const char *, char *, size_t);
+
+ 使用例
+ ret = self_convert_data("UTF-8", "ISO-2002-JP", data, 5042);
+
+説明
+ 上記の例だと、3番めの引数にあたる(data)に入れた文字列をUTF-8と断定して、
+ その文字列をISO-2002-JPに書き換え、(data）に戻す。
+ (data)の大きさは5024を越えない。
+
+
+返り値
+ 成功は0<、失敗は-*を返します。
+
+
+
+
+名前
+ SAFE_CONVERT_DATA() バッファーの文字列を、指定した文字コードから指定した文字コードに変換する。(動的バッファー)
+
+書式
+ char * safe_convert_data(const char *, const char *, char *, int *);
+
+ 使用例
+ ret = self_convert_data("UTF-8", "ISO-2002-JP", malloc_data, &ret);
+
+説明
+ 上記の例だと、3番めの引数にあたる(data)に入れた文字列をUTF-8と断定して、
+ その文字列をISO-2002-JPに書き換え、(data）に戻す。
+ (data)はヒープ。
+ retのポインターは成功は0<、失敗は-*を返します。
+
+
+返り値
+ 戻り値はoutput_dataのポインターを返す。
+
+
+
+
+
+
+
+
+ ----- 以下は時間関係の関数リファレンス -----
+
+
+
+名前
+ CHAR_WDAY() 0から6の数字から3文字の曜日を示す文字列をかえす。
+
+書式
+ char * char_wday(int (1));
+ (1) int 0から6の数字。以下は数字が示す曜日、また戻す文字列
+ 0: 日曜 Sun
+ 1: 月曜 Mon
+ 2: 火曜 Tue
+ 3: 水曜 Wed
+ 4: 木曜 Thu
+ 5: 金曜 Fri
+ 6: 土曜 Sat
+ 意外: Not!
+
+ 使用例 > char * cha = char_wday(0);
+
+説明
+ 例の場合、'Sun' という文字列がかえされる。
+
+返り値
+ 意外の数字を与えた場合は'Not!'が返される。
+
+
+
+
+
+
+
+名前
+ CHAR_MON() 0から11の数字から3文字の月を示す文字列をかえす。
+
+書式
+ char * char_mon(int (1));
+ (1) int 0から11の数字。以下は数字が示す月、また戻す文字列
+ 0: 1月 Jan
+ 1: 2月 Feb
+ 2: 3月 Mar
+ 3: 4月 Apr
+ 4: 5月 May
+ 5: 6月 Jun
+ 6: 7月 Jul
+ 7: 8月 Aug
+ 8: 9月 Sep
+ 9: 9月 Oct
+ 10: 10月 Nov
+ 11: 11月 Dec
+ 12: 12月 Dec
+ 意外: Not!
+
+ 使用例 > char * mon = char_mon(0);
+
+説明
+ 例の場合、'Jan' という文字列がかえされる。
+
+返り値
+ 意外の数字を与えた場合は'Not!'が返される。
+
+
+
+
+
+名前
+ UTIME_GETR() unix time からcharで指定した時間をかえす
+
+書式
+ int utime_getr(time_t(1), char(2));
+ (1) 指定unix time
+ (2) 文字。以下は文字が示す属性
+ 'y': 年
+ 'm': 月
+ 'd': 日
+ 'w': 曜日(0 - 6 CHAR_WDAY() を参照)
+ 'h': 時
+ 'i': 分
+ 's': 秒
+ 意外: 0 をかえす
+
+ 使用例 > int day = utime_getr((time_t)lin, 'd');
+
+説明
+ 例の場合、lin という数字をUNIX TIMEに置き換えて、その時の日日を計算して整数でかえす
+
+返り値
+ 意外の数字を与えた場合は0が返される。
+
+
+
+
+
+
+名前
+ CTIME_GETR() 現在時刻の指定文字の示す時間属性をかえす */
+
+書式
+ int ctime_getr(char (1))
+ (1) 文字。以下は文字が示す属性
+ 'y': 年
+ 'm': 月
+ 'd': 日
+ 'w': 曜日(0 - 6 CHAR_WDAY() を参照)
+ 'h': 時
+ 'i': 分
+ 's': 秒
+ 意外: 0 をかえす
+
+ 使用例 > int day = ctime_getr('d');
+
+説明
+ 例の場合、現在時刻の日日を整数でかえす
+ この関数はスレッドセーフである
+
+返り値
+ 数字以外を与えた場合は0が返される。
+
+
+
+
+
+
+名前
+ TIME_PLAS() cha 単位で t 時 に mt 時間プラスした時間を返す関数 23 + 2 = 1
+
+書式
+ int time_plas(int t(1), int mt(2), char cha(3))
+ (1) 足される時間
+ (2) 足す時間
+ (3) 文字。以下は文字が示す属性
+ 'h': 時 24 単位
+ 'i': 分 60 単位
+ 意外: 24 単位とする
+
+ 使用例 > int ha = time_plas(23, 2, 'h');
+
+説明
+ 例の場合、23時に2時間足した場合の時間、1時が返る
+ 時間と分に対してしか使えない。
+
+返り値
+ 数字以外を与えた場合は0が返される。
+
+
+
+
+
+
+
+
+
+名前
+ DAY_PLASMINUS() 一日前後の日、月、年を出す
+
+書式
+ int day_plas(int * (1), int * (2), int * (3), char(4))
+ (1) 年 整数のポインターを渡す
+ (2) 月 ”
+ (3) 日 ”
+ (4) 記号 '+' は一日プラス、'-'は一日マイナスする
+
+使用例 > day_plas(&year, &month, &day, '+');
+
+説明
+ 一日後の日月年を出す、うるう年も加味している。
+
+返り値
+ 間違いがあれば-1を返す。
+
+
+
+
+
+
+
+
+
+名前
+ GET_UNIXTIME() localな時間からUNIX時間をかえす。
+
+書式
+ time_t get_unixtime(int ye(1), int mo(2), int day(3), int hour(4), int min(5), int sec(6))
+ (1) 年 (例1970)
+ (2) 月
+ (3) 日
+ (4) 時間
+ (5) 分
+ (6) 秒
+ これらは0以下の場合は0に修正される
+
+ 使用例 > time_t tt = get_unixtime(1970, 1, 1, 1, 1, 1)
+
+説明
+ 例の場合のtt は0になるはずである
+
+返り値
+ 意外の数字を与えた場合は0が返される。
+
+
+
+
+名前
+ MESSAGE_ID() 出きるだけユニークなメッセージIDを作ります。
+
+書式
+ char * message_id(char *(1), char *(2), char *(3));
+ (1) データを戻したいバッファ、戻り値と同じポインターを指定、予めmallocされていること。
+ (2) ＠の前に入れたい名前
+ (3) ＠の後に入るドメイン
+
+ 使用例 retp = message_id(retp, "taro", "zither.ms-n.com");
+
+説明
+ 出力フォーマットは年月日時分.ランダムな数字.名前＠ドメイン名
+
+返り値
+ ポインターのアドレス。
+
+
+
+
+
+名前
+ DAY_MINUS() 現在の年月で、一日前の日をかえす。(1 - 1 = 31)
+
+書式
+ int day_minus(int(1))
+ (1) この日日から1を引いた日が返る
+
+ 使用例 > int a = day_minus(31);
+
+説明
+ 例の場合、 aには0日が入るかもしれない
+ うるう年や月が28日か30、31なのかの判断は現在の月から判断する。
+
+返り値
+ 異常の場合は-1が返る。
+
+
+
+
+
+
+
+名前
+ MONTH_LAST() 何年何月の最後の日を出す
+
+書式
+ int month_last(int(1), int(2));
+ (1) 年(例2008)
+ (2) 月(例1)
+
+ 使用例 > int mo = month_last(2008, 1);
+
+説明
+ 例の場合、moには2008年1月の最後の日である31が返る。うるう年も考慮される。
+
+返り値
+ 異常の場合は-1が返る
+
+
+
+
+
+
+
+
+名前
+ MONTH_MINUS() 指定月から一ヶ月引いた月をかえす。単純。。。
+
+書式
+ int month_minus(int(1))
+ (1) 月(1 - 12)
+
+ 使用例 > int month_minus(1);
+
+説明
+ 例の場合、1月の前の月は12月なので12が返る。
+
+返り値
+ 異常の場合は-1が返る
+
+
+
+
+
+
+
+
+名前
+ TIME_GETR() 現在時刻の:区切りの文字列をバッファにかえす。
+
+書式
+ char * time_getr(char *(1));
+ (1) 文字列を返すバッファのポインター
+
+ 使用例 > char * data = time_getr(data);
+
+説明
+ 例の場合、data に 2007:09:28:02:22:59 のような文字列が入る。
+ data は予め動的に確保されている必要がある。
+
+返り値
+ 失敗の場合は不明です。
+
+
+
+
--- /dev/null
+// alget_read.c
+// $Id: alget_read.c,v 1.4 2007/11/01 06:11:01 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<unistd.h>
+
+#include"almemsys.h"
+
+
+// char * alget_read(char *, int, int, int, int *, char, int, int);
+
+
+// fdから得たデータをネゴしながら小分けで受け取りファイルに書き出す関数。
+// mode 1 client -> server 最後にステータスを送る
+// mode 0 server -> client 受け取って終わり
+
+char * alget_read(char * filename,
+ char * rec,
+ int sk,
+ int interval,
+ int * stat,
+ char delim,
+ int file_len,
+ int mode)
+{
+FILE * fp;
+int fd;
+int count, fstat, co, onesize, allsize;
+
+fp = NULL;
+count = 0;
+fstat = 0;
+fd = 0;
+co = 0;
+onesize = 0;
+allsize = 0;
+
+while(1){
+ rec = select_fdcat(sk, rec, stat, BUF_MAX, interval); // データ受けとり
+ onesize = (int)strlen(rec);
+ allsize = allsize + onesize;
+
+ if(* stat < 0){
+ fprintf(stderr,"alget_read(1): stat < 0\n");
+ break;
+ }
+ else if((file_len * 3) < (int)strlen(rec)){
+ fprintf(stderr,"alget_read(2): file_len < rec\n");
+ break;
+ }
+ else if(co > 5000){
+ fprintf(stderr,"alget_read(3): get data len err\n");
+ break;
+ }
+ else if(allsize > BUF_MAX){
+ fprintf(stderr,"alget_read(4): get data size err\n");
+ * stat = -1;
+ break;
+ }
+
+
+ else if('\n' == (char)rec[0]){
+ if(mode == 1){
+ * stat = socket_send(sk, "200OK: stop data\n", interval);
+ }
+ break;
+ }
+ else if(0 == memcmp(rec, "400", 3)){ // 400の場合は200を返して終了(client mode 1)
+ if(mode == 1){
+ * stat = socket_send(sk, "200OK: stop data\n", interval);
+ }
+ break;
+ }
+ else if(0 == memcmp(rec, "500", 3)){
+ if(mode == 1){
+ * stat = socket_send(sk, "200OK: stop data\n", interval);
+ }
+ break;
+ }
+
+ else{
+ if(fstat == 0){
+ if((fp = fopen(filename, "w+"))!=NULL){ // file をopen
+ fd = fileno(fp);
+ }
+ else{
+ * stat = -1;
+ break;
+ }
+ fstat = 1;
+ }
+ swap_mem(rec, (char)delim, '\n'); // 0x05 を '\n'に戻す
+ count = write(fd, rec, (int)strlen(rec));
+ rec = safe_memcpy(rec, "\n", BUF_MAX);
+ }
+
+ if((* stat = socket_send(sk, "MORE\n", interval)) < 0){ // MORE の送信
+ break;
+ }
+ } // while
+
+if(fstat == 1){
+ fclose(fp);
+ }
+
+return rec;
+}
+
+
+
+
+
+
--- /dev/null
+// alget_write.c
+// $Id: alget_write.c,v 1.2 2007/11/01 06:11:01 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+
+#include"almemsys.h"
+
+
+// int alget_write(int, FILE *, int, char, int, int);
+
+
+// FPから一行ずつ読み出したデータをネゴしながら一定量小分けでsendする関数
+// mode 1 client -> server でデータを送る場合、最後はserverから受け取って終了 400
+// mode 0 server -> client の場合、自分からの送信を最後に終了 300
+
+int alget_write(int sock_fd, FILE * fp, int interval, char delim, int file_len, int mode)
+{
+char * swap;
+char * data;
+int ch, counts, stat;
+
+ch = 0;
+counts = 0;
+stat = 0;
+swap = (char *)calloc(BUF_DEFLEN, sizeof(char));
+data = (char *)calloc(BUF_DEFLEN, sizeof(char));
+
+while(1){
+
+ if(ch >=0){
+
+ // 行単位で一定量のBUFを作る
+ while(1){
+ swap = safe_fpcat(fp, swap, &ch, BUF_MAX); // file から一行swapに読む
+ swap = safe_strncat(swap, "\n", BUF_MAX); // 最後に改行追加
+ data = safe_strncat(data, swap, BUF_MAX); // data の後ろにつなぐ
+ if( file_len < (int)strlen(data) || ch < 0){ // 4K越えるか、読めない場合
+ break;
+ }
+ } // while
+
+ swap_mem(data, '\n', (char)delim); // '\n'を'0x05'に置き換え
+ counts = mem_count(data, (char)delim); // 最後に0x05がある位置
+ data[counts] = '\n'; // 最後の0x05を改行に
+ }
+
+ if(1 < (int)strlen(data)){ // data が1以上なのでdata送信
+ stat = socket_send(sock_fd, data, interval);
+ data[0] = (char)0x00;
+ }
+ else if(ch < 0){ // data 1以下なので終了送信
+ if(mode == 1){
+ stat = socket_send(sock_fd, "400OK: stop send data\n", interval);
+ swap = select_fdcat(sock_fd, swap, &stat, BUF_MAX, interval);
+ }
+ else{
+ stat = socket_send(sock_fd, "400OK: stop send data\n", interval);
+ }
+ break;
+ }
+
+ // more を受け取る
+ swap = select_fdcat(sock_fd, swap, &stat, BUF_MAX, interval);
+ if(stat < 0 || 0 != memcmp(swap, "MORE", 4)){
+ stat = socket_send(sock_fd, "500 NG file_send2(): not stat.\n", interval);
+ break;
+ }
+
+ } // while
+
+free(swap);
+free(data);
+
+return stat;
+}
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// alversion.c
+// $Id: alversion.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include <stdio.h>
+#include "almemsys.h"
+
+int alversion(void)
+{
+printf("%s\n", CL_VER);
+return 0;
+}
--- /dev/null
+
+#include<stdio.h>
+
+
+
+int outchar(int * n, char ** ptr, char c);
+
+
+/* base64 encode */
+int base64(char * data, int size, char * into)
+{
+char now[3];
+char c;
+int i, h, n;
+char * ptr;
+ptr = into;
+n = 0;
+for(i = 0; i < size; i += 3){
+ if(i + 2 < size){
+ now[0] = data[i];
+ now[1] = data[i + 1];
+ now[2] = data[i + 2];
+ c=(now[0]>>2)&0x3f;
+ outchar(&n, &ptr, c);
+ c=((now[0]<<4)&0x30) + ((now[1]>>4)&0x0f);
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ c=((now[1]<<2)&0x3c) + ((now[2]>>6)&0x03);
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ c=now[2]&0x3f;
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ }
+ else if(i + 1 < size){
+ now[0] = data[i];
+ now[1] = data[i + 1];
+ c=(now[0]>>2)&0x3f;
+ outchar(&n, &ptr, c);
+ c=((now[0]<<4)&0x30) + ((now[1]>>4)&0x0f);
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ c=((now[1]<<2)&0x3c);
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ }
+ else{
+ now[0] = data[i];
+ c=(now[0]>>2)&0x3f;
+ outchar(&n, &ptr, c);
+ c=((now[0]<<4)&0x30);
+ c&=0x3f;
+ outchar(&n, &ptr, c);
+ }
+ }
+
+h = 4 - (n%4);
+if(h != 4){
+ for(i = 0; i < h; i++){
+ *ptr = '=';
+ ptr++;
+ }
+ }
+
+*ptr='\0';
+return(0);
+}
+
+
+
+
+
+
+
+int outchar(int * n, char ** ptr, char c)
+{
+
+#ifdef BASE64_DEBUG
+printf("%d ", c);
+#endif
+
+if(c <= 25){
+ **ptr = c+'A';
+ }
+else if(c <= 51){
+ **ptr = c-26+'a';
+ }
+else if(c <= 61){
+ **ptr = c-52+'0';
+ }
+
+else if(c == 62){
+ **ptr = '+';
+ }
+
+else if(c == 63){
+ **ptr = '/';
+ }
+(*ptr)++;
+(*n)++;
+
+// if(cat > 0){
+// if((*n)%76 == 0){
+// **ptr = '\n';
+// (*ptr)++;
+// }
+// }
+
+#ifdef BASE64_DEBUG
+printf("%d ", **ptr);
+printf("%c\n", **ptr);
+#endif
+return 0;
+}
+
+
+
+
--- /dev/null
+// Bit 演算の道具
+
+#include<stdio.h>
+#include<string.h>
+#include <stdlib.h>
+
+// #define INBIT_BUG
+
+
+// char * out_bit(unsigned int ina, char * bit, int bx)
+// unsigned long in_bit(char * bit, char bx)
+
+
+
+// BIT表現の文字列 "01010101" を数字として変数に入れる
+// 1: 1,0を使ったBIT表現の文字列ポインター 2: BIT数
+unsigned long in_bit(char * bit, char bx)
+{
+unsigned long uca;
+int max, co;
+
+max = (int)strlen(bit);
+
+if(bx < 8){ bx = 9; }
+if(bx > 8 && bx < 16){ bx = 16; }
+if(bx > 16 && bx < 32){ bx = 32; }
+if(bx > 32){ bx = 32; }
+
+if(max < bx || max > bx){
+ uca = -1;
+ #ifdef INBIT_BUG
+ printf("err not data size\n");
+ #endif
+ return uca;
+ }
+
+for(co = 0; co < bx; co++){
+ if(bit[co] != '1' && bit[co] != '0'){
+ uca = -2;
+ #ifdef INBIT_BUG
+ printf("err not 0 or 1\n");
+ #endif
+ return uca;
+ }
+ }
+
+uca = (unsigned long)strtoul(bit, (char **)NULL, 2);
+
+#ifdef INBIT_BUG
+printf("<%s> %d, %d, %d, %x\n", bit, max, bx, uca, uca);
+#endif
+
+return uca;
+}
+
+
+
+
+
+// 数字をBIT表現する
+// 1: 表示したい変数 2: 予め32オクテット確保したポインター 3: 表示したいビット数
+char * out_bit(unsigned int ina, char * bit, int bx)
+{
+char tib[34];
+signed char co;
+unsigned char con;
+co = 0;
+con = 0;
+
+memset(tib, 0x00, 34);
+
+if(bx < 8){ bx = 9; }
+if(bx > 8 && bx < 16){ bx = 16; }
+if(bx > 16 && bx < 32){ bx = 32; }
+if(bx > 32){ bx = 32; }
+
+while(ina){
+ tib[co++] = ina % 2 + '0';
+ ina = ina / 2;
+ if(co >= bx){
+ break;
+ }
+ }
+
+if(co < bx){
+ while(1){
+ tib[co++] = '0';
+ if(co >= bx){
+ break;
+ }
+ }
+ }
+
+for(co = (bx - 1); co >= 0; co--){
+ bit[con] = tib[co];
+ con++;
+ }
+
+return bit;
+}
+
+
+
+
+/* お試しmain()
+
+int main(void)
+{
+char bit[34];
+
+// 関数使用
+unsigned char ua8 = in_bit("10101010", 8);
+unsigned short int usi16 = in_bit("1010101001010101", 16);
+unsigned long ul32 = in_bit("00101010010101011111111100000000", 32);
+
+memset(bit, 0x00, 34);
+
+printf( "<%s><%02lx>\n", out_bit(ua8, bit, 8), ua8 );
+printf( "<%s><%04lx>\n", out_bit(usi16, bit, 16), usi16 );
+printf( "<%s><%08lx>\n", out_bit(ul32, bit, 32), ul32 );
+
+memset(bit, 0x00, 34);
+
+ua8 = in_bit("11111111", 8);
+printf("-(1)-全部BITを立てた元データ-----------------------<%s><%d><0x%02lx>\n",
+ out_bit(ua8, bit, 8), ua8, ua8);
+
+printf("-(2)-1の下位4BITをマスク(bit単位の論理and演算 &)---<%s><%d><0x%02lx>\n",
+ out_bit(ua8 & in_bit("11110000", 8), bit, 8), ua8 & in_bit("11110000", 8), ua8 & in_bit("11110000", 8));
+
+ua8 = in_bit("00000000", 8);
+printf("-(3)-全部BITをマスクした元データ-------------------<%s><%d><0x%02lx>\n",
+ out_bit(ua8, bit, 8), ua8, ua8);
+
+printf("-(4)-3の上位4BITをON(bit単位の論理or演算 |)--------<%s><%d><0x%02lx>\n",
+ out_bit(ua8 | in_bit("11110000", 8), bit, 8), ua8 | in_bit("11110000", 8), ua8 | in_bit("11110000", 8));
+
+ua8 = in_bit("01010101", 8);
+printf("-(5)-交互にビットを立てた元データ------------------<%s><%d><0x%02lx>\n",
+ out_bit(ua8, bit, 8), ua8, ua8);
+
+printf("-(6)-5の下位4BITを反転(bit単位の排他論理or演算 ^)--<%s><%d><0x%02lx>\n",
+ out_bit(ua8 ^ in_bit("00001111", 8), bit, 8), ua8 ^ in_bit("00001111", 8), ua8 ^ in_bit("00001111", 8));
+
+printf("-(7)-5の全てのBITを無条件で反転(補数演算 ~)--------<%s><0x%02lx>\n",
+ out_bit(~ua8, bit, 8), ~ua8);
+
+printf("-(8)-5を左に3BITシフト(左シフト演算 <<)------------<%s><0x%02lx>\n",
+ out_bit(ua8 << 3, bit, 8), ua8 << 3);
+
+printf("-(9)-5を右に3BITシフト(右シフト演算 >>)------------<%s><0x%02lx>\n",
+ out_bit(ua8 >> 3, bit, 8), ua8 >> 3);
+
+usi16 = in_bit("1010101010101010", 16);
+printf("-(10)-交互にビットを立てた元データ(16Bit)----------<%s><0x%04lx>\n",
+ out_bit(usi16, bit, 16), usi16);
+
+ul32 = in_bit("10101010101010110101010101010101", 32);
+printf("-(11)-交互にビットを立てた元データ(32Bit)----------<%s><0x%08lx>\n",
+ out_bit(ul32, bit, 32), ul32);
+
+printf("-(12)-11を補数で反転(32Bit補数演算)----------------<%s><0x%08lx>\n",
+ out_bit(~ul32, bit, 32), ~ul32);
+
+printf("-(12)-11を左に16シフト(32Bit)----------------------<%s><0x%08lx>\n",
+ out_bit(ul32 << 16, bit, 32), ul32 << 16);
+
+printf("-(12)-11を右に16シフト(32Bit)----------------------<%s><0x%08lx>\n",
+ out_bit(ul32 >> 16, bit, 32), ul32 << 16);
+
+return 0;
+}
+
+*/
+
+
+
+
+
--- /dev/null
+// ch_char.c
+// $Id: $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_CHAR -------------- */
+int ch_char(char * data, char * backdata)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ if(0 != isdigit((int)data[count])){
+ backdata[ret] = data[count];
+ ret++;
+ }
+ else if(0 != isprint((int)data[count])){
+ backdata[ret] = data[count];
+ ret++;
+ }
+ else {
+ }
+ }
+
+backdata[ret] = (char)0x00;
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// ch_float.c
+// $Id: $
+
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_float(char * data)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ if(0 == isdigit((int)data[count])){
+ if('.' != data[count] && ' ' != data[count]){
+ ret = -1;
+ break;
+ }
+ }
+ }
+
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// ch_int.c
+// $Id: ch_int.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_int(char * data)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ if(0 == isdigit((int)data[count])){
+ if(data[count] == '+' || data[count] == '-'){
+ ret = 0;
+ }
+ else{
+ ret = -1;
+ break;
+ }
+ }
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// ch_int2.c
+// $Id: $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_int2(char * data)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ if(0 == isdigit((int)data[count])){
+ ret = -1;
+ break;
+ }
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// ch_int.c
+// $Id: ch_int.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_int3(char * data, char cha)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ // 基本的に全部数字の場合は０を返す
+ // もし数字以外が含まれた場合
+ if(0 == isdigit((int)data[count])){
+ // 指定されたキャラならOK
+ if(data[count] == cha){
+ ret = 0;
+ }
+ // 指定されたキャラでなければNG
+ else{
+ ret = -1;
+ break;
+ }
+ }
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_int4(char * data, char cha)
+{
+int count;
+int cret, dret, ret;
+int max = (int)strlen(data);
+
+ret = -1;
+dret = 0;
+cret = 0;
+
+for(count = 0; count < max; count++){
+
+ // もし数字以外が含まれた場合
+ if(0 == isdigit((int)data[count])){
+ // 指定されたキャラならOK
+ if(data[count] == cha){
+ cret++;
+ }
+ // 指定されたキャラでなければNG
+ else{
+ return -1;
+ }
+ }
+ // もし数字が含まれた場合
+ else{
+ dret++;
+ }
+ }
+
+if(dret > 0 && cret > 0){
+ ret = 0;
+ }
+else{
+ ret = -1;
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT_V4 -------------- */
+int ch_int_v4(char * data)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ switch((int)data[count]){
+ case '0': ret = 0; break;
+ case '1': ret = 0; break;
+ case '2': ret = 0; break;
+ case '3': ret = 0; break;
+ case '4': ret = 0; break;
+ case '5': ret = 0; break;
+ case '6': ret = 0; break;
+ case '7': ret = 0; break;
+ case '8': ret = 0; break;
+ case '9': ret = 0; break;
+ case '.': ret = 0; break;
+ default : ret = -1; break;
+ }
+ if(ret == -1){
+ return ret;
+ }
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+#include<ctype.h>
+
+
+
+/* -------------- CH_INT -------------- */
+int ch_int_v6(char * data)
+{
+int count;
+int ret = 0;
+int max = (int)strlen(data);
+
+for(count = 0; count < max; count++){
+ switch((int)data[count]){
+ case '0': ret = 0; break;
+ case '1': ret = 0; break;
+ case '2': ret = 0; break;
+ case '3': ret = 0; break;
+ case '4': ret = 0; break;
+ case '5': ret = 0; break;
+ case '6': ret = 0; break;
+ case '7': ret = 0; break;
+ case '8': ret = 0; break;
+ case '9': ret = 0; break;
+ case 'a': ret = 0; break;
+ case 'b': ret = 0; break;
+ case 'c': ret = 0; break;
+ case 'd': ret = 0; break;
+ case 'e': ret = 0; break;
+ case 'f': ret = 0; break;
+ case 'A': ret = 0; break;
+ case 'B': ret = 0; break;
+ case 'C': ret = 0; break;
+ case 'D': ret = 0; break;
+ case 'E': ret = 0; break;
+ case 'F': ret = 0; break;
+ case ':': ret = 0; break;
+ default : ret = -1; break;
+ }
+ if(ret == -1){
+ return ret;
+ }
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// char_count.c
+// $Id: char_count.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+/* --------------- CHAR COUNT ------------------ */
+int char_count(char * chData, char chA)
+{
+static int buk;
+int count;
+int inMax = (int)strlen(chData);
+
+buk = 0;
+for(count = 0; count < inMax; count++){
+ if(chData[count] == chA){
+ buk++;
+ }
+ }
+return(buk);
+}
+
+
+
+
--- /dev/null
+// char_get.c
+// $Id: char_get.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+
+/* ------------- CHAR GET ----------------------- */
+int char_get(char * data, char * chData, char chA, int inCount)
+{
+static int count2;
+int count, leng, Count;
+leng = strlen(data);
+count2 = 0;
+Count = 0;
+
+for(count = 0; count <= leng; count++){
+ if(data[count] == chA){
+ Count++;
+ }
+ if(inCount == Count){
+ if(data[count] != chA){
+ chData[count2] = data[count];
+ count2++;
+ }
+ }
+ }
+chData[count2] = (char)0x00;
+return(count2);
+}
+
+
+
+
--- /dev/null
+#include <stdio.h>
+
+#include "almemsys.h"
+
+
+// 数字月を英語月頭3文字でかえす
+char * char_mon(int mon)
+{
+char * ret;
+switch(mon){
+ case 0 : ret = "Jan"; break;
+ case 1 : ret = "Feb"; break;
+ case 2 : ret = "Mar"; break;
+ case 3 : ret = "Apr"; break;
+ case 4 : ret = "May"; break;
+ case 5 : ret = "Jun"; break;
+ case 6 : ret = "Jul"; break;
+ case 7 : ret = "Aug"; break;
+ case 8 : ret = "Sep"; break;
+ case 9 : ret = "Oct"; break;
+ case 10 : ret = "Nov"; break;
+ case 11 : ret = "Dec"; break;
+ default : ret = "Not!"; break;
+ }
+return(ret);
+}
+
+
+
--- /dev/null
+// char_point.c
+// $Id: char_point.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+/* --------------- CHAR POINT ------------------ */
+int char_point(char * chData, char chA, int po)
+{
+static int buk;
+int count;
+int inMax = (int)strlen(chData);
+
+buk = 0;
+for(count = 0; count < inMax; count++){
+ if(chData[count] == chA){
+ buk++;
+ if(buk == po){
+ return count;
+ }
+ }
+ }
+return 0;
+}
+
+
+
+
+
--- /dev/null
+#include <stdio.h>
+
+#include "almemsys.h"
+
+
+// 数字の順番で英語曜日の頭3文字をかえす
+char * char_wday(int wday)
+{
+char * ret;
+switch(wday){
+ case 0 : ret = "Sun"; break;
+ case 1 : ret = "Mon"; break;
+ case 2 : ret = "Tue"; break;
+ case 3 : ret = "Wed"; break;
+ case 4 : ret = "Thu"; break;
+ case 5 : ret = "Fri"; break;
+ case 6 : ret = "Sat"; break;
+ default : ret = "Not!"; break;
+ }
+return(ret);
+}
+
+
+
--- /dev/null
+#include<stdio.h>
+
+
+int chmem(char * data, int in)
+{
+int ret,count;
+
+ret = 0;
+
+if(in < 0){
+ ret = -1;
+ }
+else{
+ for(count = 0; count < in; count++){
+ data[count] = (char)0x00;
+ }
+ }
+
+return ret;
+}
--- /dev/null
+// clean_mem.c
+// $Id: clean_mem.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+/* ---------------- CLEAN MEM ------------------ */
+int clean_mem(char data[], char chA, int inlen)
+{
+int count, max;
+
+max = (int)strlen(data);
+if(inlen < 1 && max < 1){
+ return -1;
+ }
+
+for(count = inlen-1; 0 <= count; count = count-1){
+ data[count] = chA;
+ }
+return(count);
+
+}
+
+
+
+
+
+
+
+
--- /dev/null
+/* -- selef_convert_data() -- */
+/* -- 20120910 */
+
+#include <stdio.h>
+#include <string.h>
+#include <iconv.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+int convert(const char *input_code, const char *output_code, const char *input_text, char *output_buf, size_t output_bufsize)
+{
+iconv_t iconv_fd;
+size_t input_len, output_len;
+size_t iconv_ret;
+
+iconv_fd = iconv_open(output_code, input_code);
+if(iconv_fd == (iconv_t)-1){
+ fprintf(stderr,"iconv not open = %s <%d>\n", strerror(errno), errno);
+ iconv_close(iconv_fd);
+ return -1;
+ }
+
+input_len = strlen(input_text);
+output_len = output_bufsize - 1;
+
+iconv_ret = iconv(iconv_fd, &input_text, &input_len, &output_buf, &output_len);
+
+#ifdef ICONV_BUG
+printf("iconv stat = <ret %d> <max size %d>\n", iconv_ret, output_bufsize);
+#endif
+
+if(iconv_ret == -1){
+ fprintf(stderr, "iconv err = %s <%d>\n", strerror(errno), errno);
+ iconv_close(iconv_fd);
+ return -1;
+ }
+
+iconv_close(iconv_fd);
+return 0;
+}
+
+
+
--- /dev/null
+// count_memcpy.c
+// $Id: count_memcpy.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+
+/* ----------- COUNT MEMCPY ------------- */
+int count_memcpy(char * out, char * data, int max)
+{
+int count;
+
+for(count = 0; count < max; count ++){
+ out[count] = data[count];
+ }
+
+out[count] = (char)0x00;
+
+return(count);
+}
+
+
+
--- /dev/null
+// count_memcpy2.c
+// $Id: count_memcpy2.c,v 1.2 2007/11/01 06:12:39 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include "almemsys.h"
+
+/* ----------- COUNT MEMCPY2 ------------- */
+char * count_memcpy2(char * out, char * data, int start, int plus)
+{
+int stop, max, count, co;
+char * swap;
+max = (int)strlen(data);
+
+if(start < 0 || plus < 0 || max < 0){
+ out[0] = (char)0x00;
+ return(out);
+ }
+
+stop = start + plus;
+
+if(max < stop){
+ out[0] = (char)0x00;
+ return(out);
+ }
+
+swap = (char *)calloc(plus + 5, sizeof(char));
+
+co = 0;
+for(count = start; count <= stop; count ++){
+ swap[co] = data[count];
+ co++;
+ }
+
+swap[co] = (char)0x00;
+
+out = safe_memcpy(out, swap, BUF_MAX);
+
+free(swap);
+
+return(out);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include "almemsys.h"
+
+
+int counts(char * path_name, int min, int max)
+{
+FILE * fp;
+int stat;
+int count;
+char * data;
+
+stat = 0;
+count = 0;
+
+if(min >= max){
+ min = 0;
+ max = 1;
+ }
+
+
+data = (char *)calloc(BUF_LEN, sizeof(char));
+
+if(0 >= (int)strlen(path_name)){
+ path_name = safe_memcpy(path_name, "/tmp/taro.count", BUF_LEN);
+ }
+
+if((fp = fopen(path_name, "r+"))!=NULL){
+ data = safe_fpcat(fp, data, &stat, BUF_LEN);
+ if(0 > stat){
+ data = safe_memcpy(data, "0\n", BUF_LEN);
+ }
+ fclose(fp);
+ }
+else{
+ fprintf(stderr,"counts(): file not read open %s\n", path_name);
+ }
+
+count = strtol(data, (char **)NULL, 10);
+
+if(count < min){
+ count = min;
+ }
+else if(count > max){
+ count = max;
+ }
+else{
+ }
+
+count = count + 1;
+
+if(count > max){
+ count = min;
+ }
+
+if((fp = fopen(path_name, "w+"))!=NULL){
+ fprintf(fp,"%d\n", count);
+ fclose(fp);
+ }
+else{
+ fprintf(stderr,"counts(): file not write open %s\n", path_name);
+ }
+
+free(data);
+
+return count;
+}
+
+
+
+
+
--- /dev/null
+#include<stdio.h>
+
+#include<time.h>
+
+#include "almemsys.h"
+
+
+
+/* 現在時刻の指定文字の示す時間属性をかえす */
+int ctime_getr(char ch)
+{
+time_t t;
+struct tm tmbuf;
+
+t = time(NULL);
+localtime_r(&t, &tmbuf);
+
+switch(ch){
+ case 'y': return(tmbuf.tm_year + 1900);
+ case 'm': return(tmbuf.tm_mon + 1);
+ case 'd': return(tmbuf.tm_mday);
+ case 'h': return(tmbuf.tm_hour);
+ case 'i': return(tmbuf.tm_min);
+ case 's': return(tmbuf.tm_sec);
+ default : return(0); break;
+ }
+
+return -1;
+}
+
+
--- /dev/null
+#include "almemsys.h"
+
+// 現在の年月で、一日前の日をかえす。(1 - 1 = 31)
+int day_minus(int day_d)
+{
+int ret, day;
+ret = -1;
+day = 1;
+
+if (day_d <= 0){ day = 1; }
+else if(day_d > 31){ day = 31; }
+else { day = day_d; }
+
+if(day == 1){
+ switch(ctime_getr('m')){
+ case 1: ret = 31; break;
+ case 2: ret = 31; break;
+ case 3:
+ switch(ctime_getr('y')){
+ case 2008: ret = 29; break;
+ case 2009: ret = 28; break;
+ case 2010: ret = 28; break;
+ case 2011: ret = 28; break;
+ case 2012: ret = 29; break;
+ case 2013: ret = 28; break;
+ default: ret = 28; break;
+ }
+ break;
+ case 4: ret = 31; break;
+ case 5: ret = 30; break;
+ case 6: ret = 31; break;
+ case 7: ret = 30; break;
+ case 8: ret = 31; break;
+ case 9: ret = 31; break;
+ case 10: ret = 30; break;
+ case 11: ret = 31; break;
+ case 12: ret = 30; break;
+ default: ret = 31; break;
+ }
+ }
+else{ ret = day - 1; }
+
+return ret;
+}
+
+
+
+
--- /dev/null
+
+
+
+int isleap(int year)
+{
+return (year % 4 == 0 && year % 100 != 0 || year % 400);
+}
+
+
+// 翌日の日月年を出す関数
+int day_plasminus(int * y, int * m, int * d, char mark)
+{
+
+int day[2][13] = {
+{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }};
+
+
+if(mark == '-'){
+ if(*d != 1){
+ (*d)--;
+ }
+ else{
+ if(*m != 1){
+ (*m)--;
+ }
+ else {
+ (*y)--;
+ *m = 12;
+ }
+ *d = day[isleap(*y)][*m];
+ }
+ }
+
+else if(mark == '+'){
+ if (*d != day[isleap(*y)][*m]) {
+ (*d)++;
+ }
+ else {
+ if (*m != 12) {
+ (*m)++;
+ }
+ else {
+ (*y)++;
+ *m = 1;
+ }
+ *d = 1;
+ }
+ }
+
+return 0;
+}
+
+
+
--- /dev/null
+// delim_count.c
+// $Id: delim_count.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+extern int char_count(char *, char);
+
+/*------------------ DELIM_COUNT -------------------*/
+int delim_count(char * data, char ca, int lim, int * sta, int *sto)
+{
+int co, max, maxlen, count, ret;
+maxlen = (int)strlen(data);
+max = char_count(data, ca);
+count = 0;
+
+for(co = 0; co < maxlen; co++){
+ if(ca == data[co]){
+ if(count == (lim - 1)){
+ if(co == 0){
+ * sta = co;
+ }
+ if(co > 0){
+ * sta = co + 1;
+ }
+ }
+ if(count == lim){
+ * sto = co - 1;
+ break;
+ }
+ count++;
+ }
+ }
+
+if(co == maxlen){
+ * sto = co - 1;
+ }
+
+if(max < lim || 0 > lim){
+ * sta = 0;
+ * sto = 0;
+ ret = -1;
+ }
+else{
+ ret = (*sto - *sta + 1);
+ }
+
+return ret;
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "almemsys.h"
+
+
+
+char * delim_f(char * base, char * backdata, char deli, int count)
+{
+int co, len, ret;
+char * tmp_data1 = (char *)calloc(BUF_LEN, sizeof(char));
+char * tmp_data2 = (char *)calloc(BUF_LEN, sizeof(char));
+char * tmp_data3 = (char *)calloc(BUF_LEN, sizeof(char));
+
+len = 0;
+ret = 0;
+
+len = char_count(base, deli);
+
+
+if(count > 0 && count <= len){
+ tmp_data3 = safe_sprintf(tmp_data3, BUF_LEN,"%c", deli);
+ for(co = 0; co < count; co++){
+ tmp_data1 = delim_get(base, tmp_data1, deli, &ret, co);
+ tmp_data2 = safe_strncat(tmp_data2, tmp_data1, BUF_LEN);
+ tmp_data2 = safe_strncat(tmp_data2, tmp_data3, BUF_LEN);
+ tmp_data1 = null_free(tmp_data1);
+ }
+ backdata = safe_memcpy(backdata, tmp_data2, BUF_LEN);
+ }
+else{
+ backdata = safe_memcpy(backdata, base, BUF_LEN);
+ }
+
+free(tmp_data1);
+free(tmp_data2);
+free(tmp_data3);
+
+return backdata;
+}
+
+
--- /dev/null
+// delim_get.c
+// $Id: delim_get.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "almemsys.h"
+
+
+char * delim_get(char * swap, char * data, char delim, int * ret, int target)
+{
+int sto, sta, count;
+sta =0;
+sto =0;
+count = 0;
+* ret = 0;
+
+if(data == NULL){
+ data = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ data = null_free(data);
+ }
+
+if(swap == NULL){
+ return data;
+ }
+
+
+count = delim_count(swap, delim, target, &sta, &sto);
+#ifdef MAIL_DEBUG
+printf("DELIM 1 %d -> %d %d\n", sta, sto, count);
+#endif
+if(count > 0 && sta <= sto){
+ data = (char *)realloc(data, (count + 2) * (sizeof(char)));
+ memcount_cpm(data, swap, sta, sto, count);
+ }
+else{
+ data = (char *)realloc(data, 5 * (sizeof(char)));
+ memcpy(data, "NOT", 3);
+ data[3] = (char)0x00;
+ * ret = -1;
+ }
+#ifdef MAIL_DEBUG
+printf("data =%s\n", data);
+#endif
+
+return data;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "almemsys.h"
+
+
+
+char * delim_r(char * base, char * backdata, char deli, int count)
+{
+int co, len, ret;
+char * tmp_data1 = (char *)calloc(BUF_LEN, sizeof(char));
+char * tmp_data2 = (char *)calloc(BUF_LEN, sizeof(char));
+char * tmp_data3 = (char *)calloc(BUF_LEN, sizeof(char));
+
+len = 0;
+ret = 0;
+
+len = char_count(base, deli);
+
+
+if(count >= 0 && count <= len){
+ tmp_data3 = safe_sprintf(tmp_data3, BUF_LEN,"%c", deli);
+ for(co = count; co <= len; co++){
+ tmp_data1 = delim_get(base, tmp_data1, deli, &ret, co);
+ tmp_data2 = safe_strncat(tmp_data2, tmp_data1, BUF_LEN);
+ if(co < len){
+ tmp_data2 = safe_strncat(tmp_data2, tmp_data3, BUF_LEN);
+ }
+ tmp_data1 = null_free(tmp_data1);
+ }
+ backdata = safe_memcpy(backdata, tmp_data2, BUF_LEN);
+ }
+else{
+ backdata = safe_memcpy(backdata, base, BUF_LEN);
+ }
+
+free(tmp_data1);
+free(tmp_data2);
+free(tmp_data3);
+
+return backdata;
+}
+
+
--- /dev/null
+// file_copy.c
+// $Id: file_copy.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+
+
+/* --------- FILE COPY -------- */
+int file_copy(char * file1, char * file2)
+{
+int stat;
+FILE * fp;
+FILE * fp2;
+int inA;
+
+stat = 0;
+
+if((fp = fopen(file1, "r+"))!=NULL){
+ if((fp2 = fopen(file2, "w+"))!=NULL){
+ while(stat == 0){
+ inA = getc(fp);
+ switch(inA){
+ case EOF: stat = 1; break;
+ default : putc(inA, fp2); break;
+ }
+ }
+ }
+ else {
+ fprintf(stderr,"file_copy(): %s file not open.\n", file2);
+ stat = -1;
+ return(stat);
+ }
+ fclose(fp);
+ fclose(fp2);
+ }
+else {
+ fprintf(stderr,"file_copy(): %s file not open.\n", file1);
+ stat = -1;
+ return(stat);
+ }
+
+return(stat);
+}
+
+
+
--- /dev/null
+#include<time.h>
+
+
+// localな時間からUNIX時間をかえす。フォーマットチェックなし。
+// mktime()はWeekを無視する。
+
+time_t get_unixtime(int ye, int mo, int day, int hour, int min, int sec)
+{
+time_t ret;
+struct tm t;
+ret = 0;
+if(ye < 1970){ ye = 1970; }
+if(mo < 0){ mo = 0; }
+if(day < 0){ day = 0; }
+if(hour < 0){ hour = 0; }
+if(min < 0){ min = 0; }
+if(sec < 0){ sec = 0; }
+
+t.tm_year = (ye - 1900); /* 2001年 */
+t.tm_mon = (mo - 1); /* 5月 */
+t.tm_mday = day; /* 20日 */
+t.tm_wday = 0; /* 曜日 */
+t.tm_hour = hour; /* 14時 */
+t.tm_min = min; /* 20分 */
+t.tm_sec = sec; /* 00秒 */
+t.tm_isdst= -1; /* 夏時間無効 */
+
+ret = mktime(&t);
+
+return ret;
+}
+
--- /dev/null
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<sys/time.h>
+#include<errno.h>
+
+double gettimeofday_se(void)
+{
+struct timeval tv;
+gettimeofday(&tv, NULL);
+return tv.tv_sec + (double)tv.tv_usec*1e-6;
+}
+
+
+
--- /dev/null
+// initdaemon.c
+// $Id: initdaemon.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<unistd.h>
+#include<signal.h>
+#include<sys/types.h>
+#include<syslog.h>
+#include<string.h>
+
+// int initdaemon(void);
+//
+//int main(void)
+//{
+//
+//initdaemon();
+//
+//for(;;){
+// printf("helo\n");
+// sleep(1);
+// }
+//return 0;
+//}
+
+
+void initdaemon(char * path){
+pid_t pid;
+
+if((pid = fork()) != 0){
+ exit(0);
+ }
+
+setsid();
+
+setsid();
+
+signal(SIGHUP, SIG_IGN);
+
+if((pid = fork()) != 0){
+ exit(0);
+ }
+
+chdir(path);
+
+}
+
+
--- /dev/null
+// libms_test.c
+// $Id: libms_test.c,v 2.0 2014/02/20 masashi Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include"almemsys.h"
+
+int main(void)
+{
+int ret, sta, sto;
+char * taro = (char *)calloc(12, sizeof(char));
+char * taro2 = (char *)calloc(12, sizeof(char));
+char * hana = (char *)calloc(12, sizeof(char));
+char * sachi = (char *)calloc(12, sizeof(char));
+
+int year = 2011;
+int month = 3;
+int day = 1;
+
+
+char c8[34];
+char * ch8 = c8;
+unsigned int in8;
+
+char tt[1024];
+char * ttt = tt;
+char yy[1024];
+char * yyy = yy;
+memset(ttt, 0x00, 1024);
+memset(yyy, 0x00, 1024);
+
+ret = 0;
+sta = 0;
+sto = 0;
+
+
+alversion();
+
+self_memcpy(ttt, "12,34,56,78,90", 1024);
+self_delim_get(ttt, yyy, ',', 3, 1024);
+printf("ttt = %s, yyy = %s\n", ttt, yyy);
+
+taro = safe_memcpy(taro, "abcdef", 256);
+printf("SAFE_MEMCPY DATA =%s\n", taro);
+taro = safe_strncat(taro, "12345", 256);
+printf("SAFE_STRNCAT DATA =%s\n", taro);
+hana = safe_sprintf(hana, 256,"%s, %s, %s\n", taro, "fvbj", "12345");
+printf("SAFE_SPRINTF DATA =%s\n", hana);
+sachi = delim_get(hana, sachi, ',', &ret, 0);
+printf("DELIM_GET DATA1 =%s\n", sachi);
+sachi = delim_get(hana, sachi, ',', &ret, 1);
+printf("DELIM_GET DATA2 =%s\n", sachi);
+sachi = delim_get(hana, sachi, ',', &ret, 2);
+printf("DELIM_GET DATA3 =%s\n", sachi);
+sachi = delim_get(hana, sachi, ',', &ret, 3);
+printf("DELIM_GET DATA4 =%s\n", sachi);
+taro = safe_memcpy(taro, "-a-1-20-345", 256);
+printf("SAFE_MEMCPY DATA =%s", taro);
+ret = ch_int(taro);
+printf("CH_INT DATA= %s RET=%d\n", taro, ret);
+ret = char_count(taro, '-');
+printf("CHAR_COUNT DATA= %s RET=%d\n", taro, ret);
+ret = char_get(taro, sachi, '-', 3);
+printf("CHAR_GET DATA= %s DATA2= %s RET=%d\n", taro, sachi, ret);
+ret = char_point(taro, '-', 4);
+printf("CHAR_POINT DATA= %s RET=%d\n", taro, ret);
+ret = clean_mem(taro, '+', 3);
+printf("CLEAN_MEM DATA= %s RET=%d\n", taro, ret);
+ret = count_memcpy(taro, "abcdefghijklmn", 3);
+printf("COUNT_MEMCPY DATA= %s RET=%d\n", taro, ret);
+taro = safe_memcpy(taro, "hanako-sashiko-ayako", 256);
+ret = delim_count(taro, '-', 1, &sta, &sto);
+printf("DELIM_COUNT DATA= %s RET=%d STA= %d STO= %d\n", taro, ret, sta, sto);
+ret = mem_count(taro, '-');
+printf("MEM_COUNT DATA= %s RET=%d\n", taro, ret);
+ret = memcount_cpm(taro, "12345", 1, 3, 4);
+printf("MEMCOUNT_CPM DATA= %s RET=%d\n", taro, ret);
+taro = safe_memcpy(taro, "abcdef\r\n", 256);
+ret = rm_crlf(taro, (int)strlen(taro));
+printf("RM_CRLF DATA= %s RET=%d\n", taro, ret);
+ret = set_mem(taro, 'd', (int)strlen(taro));
+printf("SET_MEM DATA= %s RET=%d\n", taro, ret);
+taro = safe_memcpy(taro, "02020", 256);
+ret = swap_mem(taro, '2', '1');
+printf("SWAP_MEM DATA= %s RET=%d\n", taro, ret);
+ret = unlinkdir("/home/masashi/dirtest/");
+printf("UNLINKDIR PATH= %s RET=%d\n", "/home/masashi/dirtest/", ret);
+printf("char_wday(1) = %s\n", char_wday(1));
+printf("char_mon(1) = %s\n", char_wday(1));
+printf("utime_getr(, 'y') = %d\n", utime_getr(time(NULL), 'y'));
+printf("utime_getr(, 'm') = %d\n", utime_getr(time(NULL), 'm'));
+printf("utime_getr(, 'd') = %d\n", utime_getr(time(NULL), 'd'));
+printf("cutime_getr('y') = %d\n", ctime_getr('y'));
+printf("cutime_getr('m') = %d\n", ctime_getr('m'));
+taro = message_id(taro, "test", "ms-n.com");
+printf("Message_id(%s)\n", taro);
+
+taro = safe_memcpy(taro, "jjjjjjjjjjjjj", 1000);
+taro = safe_ujtoj(taro);
+printf("safe_ujtoj(): <%s>\n", taro);
+
+
+taro = safe_memcpy(taro, "ほげほげモリモリかりかりうへうへ大言講師総領事館現在管理反省高額支給者安全保証期間ほほほほほほままままままはり込んだ為ガタ濃い地金これが中謝金じゃじじじじじじここここここ\nここばばばばばばれあいふいれごろいれごろいれぎり\nのほの麹ほのほのほ憂鬱これこれにゃは林檎ははは奪回はははは", 1000);
+taro = safe_convert_data("UTF-8", "EUC-JP", taro, &ret);
+taro = safe_convert_data("EUC-JP", "UTF-8", taro, &ret);
+printf("safe_convert_data(): <%s>\n", taro);
+taro = safe_convert_data("UTF-8", "ISO-2022-JP", taro, &ret);
+taro = safe_convert_data("ISO-2022-JP", "EUC-JP", taro, &ret);
+taro = safe_convert_data("EUC-JP", "UTF-8", taro, &ret);
+printf("safe_convert_data(): <%s>\n", taro);
+taro = safe_convert_data("UTF-8", "EUC-JP", taro, &ret);
+taro = mime_ujtoj(taro);
+printf("mime_ujtoj(): <%s>\n", taro);
+
+
+taro = safe_memcpy(taro, "@1234567890@", 1000);
+memset(ch8, 0x00, 34);
+in8 = in_bit("01010101", 8);
+ch8 = out_bit(in8, ch8, 8);
+
+printf("in_bit() out_bit(): <%d><%s><%d>\n", in8, ch8, (int)in_bit(ch8, 8));
+
+taro = safe_memcpy(taro, "121212121212121212", 1000);
+printf("taro 1: <%s>\n", taro);
+ret = rm_char(taro, '1');
+printf("taro 2: <%s>%d\n\n", taro, ret);
+
+taro = safe_memcpy(taro, "121212121212121212", 1000);
+printf("taro 1: <%s>\n", taro);
+ret = rm_char(taro, '2');
+printf("taro 2: <%s>%d\n\n", taro, ret);
+
+taro = safe_memcpy(taro, "101010101001", 1000);
+printf("taro 1: <%s>\n", taro);
+ret = rm_char(taro, '0');
+printf("taro 2: <%s>%d\n\n", taro, ret);
+
+printf("count(): <%d>\n", counts("/tmp/hage", 1, 3));
+
+taro = safe_memcpy(taro, "aaa,bbb,ccc,ddd,", 1000);
+taro2 = delim_f(taro, taro2, ',', 2);
+printf("delim_f(): %s <%s>\n", taro, taro2);
+
+taro = safe_memcpy(taro, "aaa,bbb,ccc,ddd,", 1000);
+taro2 = delim_r(taro, taro2, ',', 4);
+printf("delim_r(): %s <%s>\n", taro, taro2);
+
+taro = safe_memcpy(taro, "aaa,bbb,ccc,ddd", 1000);
+taro2 = delim_r(taro, taro2, ',', 0);
+printf("delim_r(): %s <%s>\n", taro, taro2);
+
+printf("mem_tcount(): %d\n", mem_tcount("012345678", '1'));
+
+// taro = safe_memcpy(taro, "000:110:002:003:004", 128);
+taro = safe_memcpy(taro, "0:0", 128);
+printf("==1==%s==\n", taro);
+swap_armem(taro, ':', '-', 3, 7);
+printf("==2==%s==\n", taro);
+
+taro = safe_memcpy(taro, "-", 128);
+printf("==ch_int4()test===%s==%d==\n", taro, ch_int4(taro, '-'));
+
+printf("===shift8_updown_out(1)=t==%d=====\n", shift8_updown_out(shift8_updown_in(1,2,3,4), 't'));
+printf("===shift8_updown_out(2)=m==%d=====\n", shift8_updown_out(shift8_updown_in(1,2,3,4), 'm'));
+printf("===shift8_updown_out(3)=u==%d=====\n", shift8_updown_out(shift8_updown_in(1,2,3,4), 'u'));
+printf("===shift8_updown_out(4)=t==%d=====\n", shift8_updown_out(shift8_updown_in(1,2,3,4), 'd'));
+printf("==================================\n");
+printf("===shift8_updown_out(5)=t==%d=====\n", shift8_updown_out(65793, 't'));
+printf("===shift8_updown_out(5)=m==%d=====\n", shift8_updown_out(65793, 'm'));
+printf("===shift8_updown_out(5)=u==%d=====\n", shift8_updown_out(65793, 'u'));
+printf("===shift8_updown_out(5)=d==%d=====\n", shift8_updown_out(65793, 'd'));
+printf("==================================\n");
+printf("===shift8_updown_in(1,2,3,4)===%d=====\n", shift8_updown_in(1,2,3,4));
+printf("===shift8_updown_in(1,1,1,1)===%d=====\n", shift8_updown_in(1,1,1,1));
+printf("===shift8_updown_in(0,1,1,1)===%d=====\n", shift8_updown_in(0,1,1,1));
+printf("===shift8_updown_in(0,0,1,1)===%d=====\n", shift8_updown_in(0,0,1,1));
+printf("===shift8_updown_in(0,1,0,1)===%d=====\n", shift8_updown_in(0,1,0,1));
+printf("===shift8_updown_in(0,1,5,1)===%d=====\n", shift8_updown_in(0,1,5,1));
+printf("===shift8_updown_in(0,2,8,2)===%d=====\n", shift8_updown_in(0,2,8,2));
+printf("===shift8_updown_in(0,0,3,3)===%d=====\n", shift8_updown_in(0,0,3,3));
+printf("==================================\n");
+printf("===shift8_updown_out(6)=t==%d=====\n", shift8_updown_out(16843009, 't'));
+printf("===shift8_updown_out(6)=m==%d=====\n", shift8_updown_out(16843009, 'm'));
+printf("===shift8_updown_out(6)=u==%d=====\n", shift8_updown_out(16843009, 'u'));
+printf("===shift8_updown_out(6)=d==%d=====\n", shift8_updown_out(16843009, 'd'));
+printf("==================================\n");
+printf("===shift8_updown_out(7)=t==%d=====\n", shift8_updown_out(65793, 't'));
+printf("===shift8_updown_out(7)=m==%d=====\n", shift8_updown_out(65793, 'm'));
+printf("===shift8_updown_out(7)=u==%d=====\n", shift8_updown_out(65793, 'u'));
+printf("===shift8_updown_out(7)=d==%d=====\n", shift8_updown_out(65793, 'd'));
+
+printf("start %d + stop %d = amari %d\n", 23, 2, time_plas( 23, 2, 'h'));
+printf("start %d + stop %d = amari %d\n", 0, 1, time_plas( 0, 1, 'h'));
+printf("start %d + stop %d = amari %d\n", 23, 1, time_plas( 23, 1, 'h'));
+printf("start %d + stop %d = amari %d\n", 3, 1, time_plas( 3, 1, 'h'));
+printf("start %d + stop %d = amari %d\n", 24, 1, time_plas( 24, 1, 'h'));
+printf("start %d + stop %d = amari %d\n", 24, 1, time_plas( 24, 1, 'h'));
+printf("start %d + stop %d = amari %d\n", 12, 1, time_plas( 12, 1, 'j'));
+
+printf("set year = %d month = %d day = %d\n", year, month, day);
+day_plasminus(&year, &month, &day, '-');
+printf("mainus year = %d month = %d day = %d\n", year, month, day);
+day_plasminus(&year, &month, &day, '+');
+printf("plas year = %d month = %d day = %d\n", year, month, day);
+
+printf("====== get_unixtime(%d):min 0=====\n", (int) get_unixtime(2013, 3, 21, 1, 0, 0));
+printf("====== get_unixtime(%d):min 60=====\n", (int) get_unixtime(2013, 3, 21, 1, 60, 0));
+
+
+return 0;
+}
+
+
+
+
--- /dev/null
+// mem_count.c
+// $Id: mem_count.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+/* --------------- MEM COUNT ------------------ */
+int mem_count(char * chData, char chA)
+{
+int buk;
+int count;
+int inMax = strlen(chData);
+
+buk = 0;
+for(count = 0; count < inMax; count++){
+ if(chData[count] == chA){
+ buk=count;
+ }
+ }
+return(buk);
+}
+
+
+
--- /dev/null
+#include<stdio.h>
+#include<string.h>
+
+
+
+int mem_tcount(char * chData, char chA)
+{
+int buk;
+int count;
+int inMax = strlen(chData);
+
+buk = -1;
+for(count = 0; count < inMax; count++){
+ if(chData[count] == chA){
+ buk=count;
+ return(buk);
+ }
+ }
+return(buk);
+}
+
+
+
--- /dev/null
+// memcount_cpm.c
+// $Id: memcount_cpm.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+/* --------------- MEMCOUNT_CPM ---------------- */
+int memcount_cpm(char * back, char * data, int sta, int sto, int len)
+{
+int max, count, count1;
+max = (int)strlen(data);
+count1 = 0;
+
+if(max < 1 || sto < sta){
+ return -1;
+ }
+
+for(count = sta; count <= sto && count < max; count++){
+ back[count1] = data[count];
+ count1++;
+ if(count1 >= len){
+ break;
+ }
+ }
+
+back[count1] = (char)0x00;
+
+return count;
+}
+
+
+
--- /dev/null
+#include<stdio.h>
+#include<time.h>
+
+#include "almemsys.h"
+
+char * message_id(char * backdata, char * name, char * domain)
+{
+time_t tt;
+tt = time(NULL);
+
+backdata = safe_sprintf(backdata, BUF_MAX,"%d%d%d%d%d%d.%d.%s@%s",
+ utime_getr(tt, 'y'),
+ utime_getr(tt, 'm'),
+ utime_getr(tt, 'd'),
+ utime_getr(tt, 'h'),
+ utime_getr(tt, 'i'),
+ utime_getr(tt, 's'),
+ randdata(100000, 999999),
+ name,
+ domain);
+
+return backdata;
+}
--- /dev/null
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include"almemsys.h"
+
+/* ujtoj komata mitsuyuki著 TCP_IP ネットワークプログラミング引用 */
+
+#define iseuckanji(c) (0xa1<=(unsigned char)(c&0xff) && (unsigned char)(c&0xff)<=0xfe)
+#define iseuckana(c) (0x8e==(unsigned char)(c&0xff))
+
+
+
+char * mime_ujtoj(char * from)
+{
+int i, len, c, kanji_flag, flag;
+char * head = "=?ISO-2022-jp?B?";
+char * tail = "?=";
+char ato[128];
+char * to = ato;
+char * data = (char *)calloc(2, sizeof(char));
+char * swap = (char *)calloc(2, sizeof(char));
+
+memset(to, 0x00, 128);
+
+len = (int)strlen(from);
+c = 0;
+kanji_flag = 0;
+flag = 0;
+
+for(i = 0; i < len; i++){
+ if(iseuckanji(from[i])){ // kanji
+ if(kanji_flag == 0){
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x24;
+ c++;
+ to[c] = 0x42;
+ c++;
+ kanji_flag = 1;
+ }
+ to[c] = (from[i]&0x7f);
+ c++;
+ to[c] = (from[i+1]&0x7f);
+ c++;
+ i++;
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: kanji %d\n", c);
+ #endif
+
+ if(c > (76 - 17 * 3 / 4)){
+
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x28;
+ c++;
+ to[c] = 0x4a;
+ c++;
+
+ to[c] = 0x00;
+ c = 0;
+ swap = safe_memcpy(swap, to, BUF_MAX);
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: kanji <%x> %s \n",swap[0], swap);
+ #endif
+
+ swap = safe_base64(swap);
+ if(flag == 0){
+ data = safe_memcpy(data, head, BUF_MAX);
+ }
+ else{
+ data = safe_strncat(data, "\t ", BUF_MAX);
+ data = safe_strncat(data, head, BUF_MAX);
+ }
+ data = safe_strncat(data, swap, BUF_MAX);
+ data = safe_strncat(data, tail, BUF_MAX);
+ data = safe_strncat(data, "\r\n", BUF_MAX);
+ memset(to, 0x00, 128);
+ flag = 1;
+ kanji_flag = 0;
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: kanji %s\n",data);
+ #endif
+
+ }
+
+ }
+ else{ // not kanji
+ if(kanji_flag == 1){
+
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x28;
+ c++;
+ to[c] = 0x4a;
+ c++;
+ kanji_flag = 0;
+ }
+
+ to[c] = from[i];
+ c++;
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: not kanji %d\n", c);
+ #endif
+
+ if(c > (76 - 17 * 3 / 4)){
+ to[c] = 0x00;
+ c =0;
+ swap = safe_memcpy(swap, to, BUF_MAX);
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: not kanji <%x> %s \n",swap[0], swap);
+ #endif
+
+ swap = safe_base64(swap);
+ if(flag == 0){
+ data = safe_memcpy(data, head, BUF_MAX);
+ }
+ else{
+ data = safe_strncat(data, "\t ", BUF_MAX);
+ data = safe_strncat(data, head, BUF_MAX);
+ }
+ data = safe_strncat(data, swap, BUF_MAX);
+ data = safe_strncat(data, tail, BUF_MAX);
+ data = safe_strncat(data, "\r\n", BUF_MAX);
+ memset(to, 0x00, 128);
+ flag = 1;
+ kanji_flag = 1;
+
+ #ifdef MIME_BASE64_BUG
+ printf("MIME_BASE64_BUG: mime_base64.c: not kanji %s\n",data);
+ #endif
+
+ }
+
+ }
+ }
+
+
+to[c] = 0x1b;
+c++;
+to[c] = 0x28;
+c++;
+to[c] = 0x4a;
+c++;
+
+to[c] = '\0';
+swap = safe_memcpy(swap, to, BUF_MAX);
+
+#ifdef MIME_BASE64_BUG
+printf("MIME_BASE64_BUG: mime_base64.c: owari <%x> %s \n",swap[0], swap);
+#endif
+
+swap = safe_base64(swap);
+
+if(flag == 0){
+ data = safe_memcpy(data, head, BUF_MAX);
+ }
+else{
+ data = safe_strncat(data, "\t ", BUF_MAX);
+ data = safe_strncat(data, head, BUF_MAX);
+ }
+data = safe_strncat(data, swap, BUF_MAX);
+data = safe_strncat(data, tail, BUF_MAX);
+
+#ifdef MIME_BASE64_BUG
+printf("MIME_BASE64_BUG: mime_base64.c: owari %s\n",data);
+#endif
+
+
+from = safe_memcpy(from, data, BUF_MAX);
+free(swap);
+free(data);
+
+return from;
+}
+
+
+
+
+
--- /dev/null
+// mlexit.c
+// $Id: mlexit.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<stdlib.h>
+
+int mlexit(void);
+
+int mlexit(void)
+{
+fprintf(stderr, "malloc() Not set buffer. exit\n");
+exit(1);
+return 0;
+}
+
+
+
--- /dev/null
+
+
+
+int m_last(int uu, int mon)
+{
+int ret;
+ret = -1;
+
+switch(mon){
+ case 1: ret = 31; break;
+ case 2: if(uu == 1){
+ ret = 29;
+ }
+ else{
+ ret = 28;
+ }
+ break;
+ case 3: ret = 31; break;
+ case 4: ret = 30; break;
+ case 5: ret = 31; break;
+ case 6: ret = 30; break;
+ case 7: ret = 31; break;
+ case 8: ret = 31; break;
+ case 9: ret = 30; break;
+ case 10: ret = 31; break;
+ case 11: ret = 30; break;
+ case 12: ret = 31; break;
+ default: ret = 0; break;
+ }
+
+return ret;
+}
+
+
+
+// 何年何月の最後の日を出す
+int month_last(int ye, int mon)
+{
+int ret;
+ret = -1;
+
+switch(ye){
+ case 2008: ret = m_last(1, mon); break;
+ case 2009: ret = m_last(0, mon); break;
+ case 2010: ret = m_last(0, mon); break;
+ case 2011: ret = m_last(0, mon); break;
+ case 2012: ret = m_last(1, mon); break;
+ case 2013: ret = m_last(0, mon); break;
+ case 2014: ret = m_last(0, mon); break;
+ case 2015: ret = m_last(0, mon); break;
+ case 2016: ret = m_last(1, mon); break;
+ case 2017: ret = m_last(0, mon); break;
+ case 2018: ret = m_last(0, mon); break;
+ case 2019: ret = m_last(0, mon); break;
+ case 2020: ret = m_last(1, mon); break;
+ default: ret = 0; break;
+ }
+
+return ret;
+}
+
+
+
+
+
+
--- /dev/null
+
+
+
+// 指定月から一ヶ月引いた月をかえす。単純。。。
+int month_minus(int month)
+{
+int ret;
+ret = -1;
+
+switch(month){
+ case 1: ret = 12; break;
+ case 2: ret = 1; break;
+ case 3: ret = 2; break;
+ case 4: ret = 3; break;
+ case 5: ret = 4; break;
+ case 6: ret = 5; break;
+ case 7: ret = 6; break;
+ case 8: ret = 7; break;
+ case 9: ret = 8; break;
+ case 10: ret = 9; break;
+ case 11: ret = 10; break;
+ case 12: ret = 11; break;
+ default: ret = 0; break;
+ }
+
+return ret;
+}
+
+
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+
+char * null_free(char * data)
+{
+int len;
+len = (int)strlen(data);
+
+if(0 < len){
+
+ #ifdef NULL_FREEBUG
+ printf("null_free(%d) %s\n", len, data);
+ #endif
+
+ memset(data, 0x00, len);
+ }
+
+return data;
+}
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<time.h>
+#include<sys/time.h>
+
+int utimesec()
+{
+struct timeval tv;
+gettimeofday(&tv, NULL);
+return (int)tv.tv_usec;
+}
+
+int randdata(int min, int max)
+{
+int a, in_max;
+time_t t;
+
+if(min >= max){
+ min = 0;
+ max = 1;
+ }
+
+in_max = (max - min) + 1;
+
+t = utimesec();
+srandom((unsigned int)t);
+a = min + (int) ((double)in_max * random() / (RAND_MAX + 1.0));
+
+#ifdef RANDDATA_BUG
+printf("RANDDATA_BUG: randdata.c: utime=%d, randam=%d\n", t, a);
+#endif
+
+return a;
+}
+
+
+// int main(void)
+// {
+// int co;
+
+// for(co = 0; co < 100; co++){
+// printf("%d\n", randdata(3, 7));
+// }
+
+// return 0;
+// }
+
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include "almemsys.h"
+
+// int rm_char(char * data, char ch, int max);
+
+int rm_char(char * data, char ch)
+{
+int max, comax, ret, co, po, pp;
+
+ret = 0;
+
+max = strlen(data);
+comax = char_count(data, ch);
+
+if(comax > 0){
+ ret = comax;
+ for(co = comax; co > 0; co--){
+ pp = mem_count(data, ch);
+ for(po = pp; po < max; po++){
+ data[po] = data[po + 1];
+ }
+ data[po] = (char)0x00;
+ }
+ }
+else{
+ return ret;
+ }
+
+return ret;
+}
+
+
--- /dev/null
+// rm_crlf.c
+// $Id: rm_crlf.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+
+/*------------------ RM CRLF -------------------*/
+int rm_crlf( char data[], int count )
+{
+static int inA;
+inA = 0;
+for(; inA < count; ){
+ if( data[inA] == (char)0x0a || data[inA] == (char)0x0d ){
+ data[inA] = (char)0x00;
+ }
+ inA++;
+ }
+return(inA);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include"almemsys.h"
+
+
+// char * safe_base64(char *, int, int);
+
+
+char * safe_base64(char * data)
+{
+char * swap;
+int max;
+
+max = (int)strlen(data);
+
+if(max > 0){
+ swap = (char *)calloc((max * 2), (int)sizeof(char));
+ base64(data, max, swap);
+ data = safe_memcpy(data, swap, BUF_MAX);
+ free(swap);
+ }
+else{
+ fprintf(stderr,"safe_base64(): not 64 encode.\n");
+ }
+
+return data;
+}
+
+
+
--- /dev/null
+/* -- selef_convert_data() -- */
+/* -- 20120910 */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iconv.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+char * safe_convert_data(const char * input_code, const char * output_code, char * data, int * ret)
+{
+char * inbuf;
+char * outbuf;
+int max;
+// int count;
+
+max = (int)strlen(data);
+
+if(max > 0){
+ inbuf = (char *)calloc(max * 2, sizeof(char));
+ outbuf = (char *)calloc(max * 2, sizeof(char));
+ inbuf = safe_memcpy(inbuf, data, max);
+
+ ret = convert(input_code, output_code, inbuf, outbuf, (max * 2));
+
+ data = safe_memcpy(data, outbuf, (max * 2));
+
+ free(inbuf);
+ free(outbuf);
+ }
+else{
+ fprintf(stderr,"safe_convert_data(): data size err.\n");
+ }
+
+return data;
+}
+
+
+
+
+
+
+
--- /dev/null
+// safe_fdcat.c
+// $Id: safe_fdcat.c,v 1.3 2007/11/01 05:54:46 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<errno.h>
+#include<unistd.h>
+
+#include "almemsys.h"
+
+
+char * safe_fdcat(int sk, char * all_data, int * stat, int max_len, int interval)
+{
+char buff[BUF_DEFLEN];
+int indata, allcu;
+
+allcu = 0;
+
+if(all_data == NULL){
+ all_data = (char *)calloc(BUF_DEFLEN, sizeof(char));
+ }
+else{
+ all_data = null_free(all_data);
+ }
+
+while(1){
+ if((indata = socket_reads(sk, buff, sizeof(buff), interval)) > 0){
+ if(NULL != (strchr(buff, (int)'\n'))){
+ allcu = allcu + indata;
+ #ifdef SOCKET_BUG
+ fprintf(stderr,"safe_fdcat(1): 改行読んだし 脱出！ 全部で %d バイト読んだよ！\n", allcu);
+ #endif
+ buff[indata] = (char)0x00;
+ all_data = safe_strncat(all_data, buff, BUF_MAX);
+ break;
+ }
+ else{
+ allcu = allcu + indata;
+ #ifdef SOCKET_BUG
+ fprintf(stderr,"sfe_fdcat(2): %d バイト足して、いまんとこ %d バイト読んだよ！\n",
+ indata, allcu);
+ #endif
+ buff[indata] = (char)0x00;
+ all_data = safe_strncat(all_data, buff, BUF_MAX);
+ if(allcu > max_len){
+ #ifdef SOCKET_BUG
+ fprintf(stderr,"safe_fdcat(3): たいへんだぁー！ %d も読んでるよ、おなかいっぱい\n", allcu);
+ #endif
+ all_data = safe_memcpy(all_data, "\n", BUF_MAX);
+ allcu = -1;
+ break;
+ }
+ }
+ }
+ else{
+ #ifdef SOCKET_BUG
+ fprintf(stderr,"safe_fdcat(4): recv失敗したし 脱出！ \n");
+ #endif
+ allcu = -1;
+ all_data = safe_memcpy(all_data, "\n", BUF_MAX);
+ break;
+ }
+ } // while()
+
+
+* stat = allcu;
+return all_data;
+
+}
+
+
+
--- /dev/null
+// safe_fdcpm.c
+// $Id: safe_fdcpm.c,v 1.2 2007/10/17 10:57:56 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+
+char * safe_fdcpm(int sk, char * getdata, int * stat, int max_len, int interval)
+{
+int indata = 0;
+int inlen = 0;
+int count = 0;
+int plen = 0;
+char bf[BUF_DEFLEN];
+char * buf = bf;
+
+if(getdata == NULL){
+ getdata = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ getdata = null_free(getdata);
+ }
+
+while(1){
+ if((indata = socket_reads(sk, buf, BUF_DEFLEN, interval)) < 1){
+ fprintf(stderr, "safe_fdcpm(): farst read err indata=%d\n", indata);
+ fprintf(stderr, "ERRNO: %s\n", strerror(errno));
+ * stat = -1;
+ return NULL;
+ }
+
+ buf[indata] = (char)0x00;
+
+ if(indata <= BUF_DEFLEN && indata > 0){
+ if(max_len >= (inlen + indata)){
+ inlen = inlen + indata;
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(getdata, buf, (indata + 1));
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ count = mem_count(getdata, (char)0x0a);
+ if(getdata[count] == (char)0x0a && count >= 0){
+ getdata[count+1] = (char)0x00;
+ #ifdef AL_DEBUG
+ printf("(1nomall)COUNT=<%d>COUNTALL=<%d>RIALCOUNT=<%d>GETDATA=<%s>POINT<%p><%d>\n",
+ indata, inlen, (int)strlen(getdata), getdata, getdata, count);
+ #endif
+ * stat = 0;
+ return getdata;
+ }
+ }
+
+ if(max_len < (inlen + indata)){
+ plen = indata - (inlen - max_len);
+ inlen = max_len;
+ fprintf(stderr,"memory max count err. %d\n", inlen);
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(getdata, buf, (plen + 1));
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ getdata[inlen - 1] = (char)0x00;
+ #ifdef AL_DEBUG
+ printf("(1 nomall)COUNT=<%d>COUNTALL=<%d>RIALCOUNT=<%d>GETDATA=<%s>POINT<%p>P<%d>\n",
+ indata, inlen, (int)strlen(getdata), getdata, getdata, plen);
+ #endif
+ * stat = 0;
+ return getdata;
+ }
+ }
+ }
+
+return NULL;
+}
+
+
+
+
+
--- /dev/null
+// safe_filefdcat.c
+// $Id: safe_filefdcat.c,v 1.2 2007/10/17 10:57:56 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+
+char * safe_filefdcat(int sk, char * getdata, int * stat, int max_len, int interval)
+{
+int indata = 0;
+int inlen = 0;
+int plen = 0;
+char bf[BUF_DEFLEN];
+char * buf = bf;
+
+memset(buf, 0x00, BUF_DEFLEN);
+
+if(getdata == NULL){
+ getdata = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ getdata = null_free(getdata);
+ }
+
+while(1){
+ if((indata = socket_reads(sk, buf, BUF_DEFLEN, interval)) < 1){
+/* fprintf(stderr, "safe_filefdcat(): farst read err indata=%d\n", indata);
+ fprintf(stderr, "ERRNO: %s\n", strerror(errno)); */
+ * stat = -1;
+ return getdata;
+ }
+
+ buf[indata] = (char)0x00;
+
+ if(indata <= BUF_DEFLEN && indata > 0){
+ if(max_len >= (inlen + indata)){
+ inlen = inlen + indata;
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 3)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(getdata, buf, (indata + 1));
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ }
+
+ if(max_len < (inlen + indata)){
+ plen = indata - (inlen - max_len);
+ inlen = max_len;
+ fprintf(stderr,"memory max count err. %d\n", inlen);
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 3)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(getdata, buf, plen + 1);
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ getdata[inlen] = (char)0x00;
+ #ifdef AL_DEBUG
+ printf("(1 nomall)COUNT=<%d>COUNTALL=<%d>RIALCOUNT=<%d>GETDATA=<%s>POINT<%p>P<%d>\n",
+ indata, inlen, (int)strlen(getdata), getdata, getdata, plen);
+ #endif
+ while(1){
+ indata = socket_reads(sk, buf, BUF_DEFLEN, interval);
+ if(indata == 0){
+ return getdata;
+ }
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ }
+
+ }
+ }
+ }
+return getdata;
+}
+
+
+
+
--- /dev/null
+// safe_fpcat.c
+// $Id: safe_fpcat.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+
+char * safe_fpcat(FILE * fp, char * getdata, int * stat, int max_len)
+{
+char data[BUF_DEFLEN];
+unsigned int chA;
+int count = 0;
+int fp_stat = 0;
+
+if(getdata == NULL){
+ getdata = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ getdata = null_free(getdata);
+ }
+
+while(fp_stat == 0){
+ chA = fgetc(fp);
+
+ switch(chA){
+ case '\n': data[count] = (char)0x00;
+ getdata = safe_strncat(getdata, data, max_len);
+ fp_stat = 1;
+ break;
+ case EOF : data[count] = (char)0x00;
+ getdata = safe_strncat(getdata, data, max_len);
+ fp_stat = 1;
+ * stat = -1;
+ break;
+ default : data[count] = chA;
+ if(count < max_len){
+ count++;
+ }
+ if(count >= max_len){
+ data[count] = (char)0x00;
+ getdata = safe_strncat(getdata, data, max_len);
+ fp_stat = 1;
+ return getdata;
+ }
+ break;
+ } /* switch */
+
+ if(count > (BUF_DEFLEN -2) && fp_stat != 1){
+ data[count] = (char)0x00;
+ getdata = safe_strncat(getdata, data, max_len);
+ clean_mem(data, (char)0x00, (int)strlen(data));
+ count = 0;
+ }
+ } /* while */
+#ifdef AL_DEBUG
+printf("GET DATA2 %s <%d>\n", getdata, (int)strlen(getdata));
+#endif
+return getdata;
+}
+
+
+
+
+
--- /dev/null
+// safe_memcpy.c
+// $Id: safe_memcpy.c,v 1.2 2007/10/17 10:57:56 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+char * safe_memcpy(char * buf, char * newdata, int max_len)
+{
+int data_count;
+
+if(newdata == NULL){
+ fprintf(stderr,"safe_memcpy(0): insert data is NULL.\n");
+ buf = null_free(buf);
+ return buf;
+ }
+else if(newdata[0] == (char)0x00){
+ buf = null_free(buf);
+ return buf;
+ }
+
+data_count = (int)strlen(newdata);
+
+if(buf == NULL){
+ buf = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ buf = null_free(buf);
+ }
+
+if(max_len < data_count){
+ if((buf = (char *)realloc(buf, (max_len + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ memset(buf, (char)0x00, max_len);
+ count_memcpy(buf, newdata, max_len);
+ fprintf(stderr,"data size err %s %d %d\n", buf, data_count, max_len);
+ return buf;
+ }
+else {
+ if((buf = (char *)realloc(buf, (data_count + 2)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ memset(buf, (char)0x00, data_count + 1);
+ count_memcpy(buf, newdata, data_count);
+ #ifdef AL_DEBUG
+ printf("COUNT = <%d> GET DATA = <%s>\n", data_count, buf);
+ #endif
+ return buf;
+ }
+
+return NULL;
+}
+
+
+
+
--- /dev/null
+
+
+#include<stdio.h>
+#include<unistd.h>
+#include<pthread.h>
+
+int safe_pthread_mutex_lock(pthread_mutex_t * mu)
+{
+int ret, uint;
+uint = 10000;
+
+while(1){
+ ret = pthread_mutex_trylock(mu);
+ if(0 == ret){
+ break;
+ }
+ else{
+ #ifdef THREAD_LOCK_BUG
+ fprintf(stderr,"pthread trylock err. <%d> <%d>\n", (int)mu, uint);
+ #endif
+ }
+ if(uint > 500000){ uint = 500000; }
+ usleep(uint);
+ uint = uint + 10000;
+ }
+
+return ret;
+}
--- /dev/null
+// safe_sprintf.c
+// $Id: safe_sprintf.c,v 1.2 2007/11/01 06:08:31 sendan Exp $
+// masashi shimakura
+
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<stdarg.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+__attribute__((__format__(__printf__, 3, 4))) char * safe_sprintf(char * data, long int max_len, const char * fmt,...)
+{
+FILE * fp;
+va_list args;
+long int len;
+
+if(data == NULL){
+ data = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ data = null_free(data);
+ }
+
+va_start(args, fmt);
+if((fp = fopen("/dev/null", "w+"))!=NULL){
+ len = vfprintf(fp, fmt, args);
+ fclose(fp);
+ }
+else{
+ len = vfprintf(stderr, fmt, args);
+ }
+va_end(args);
+
+va_start(args, fmt);
+if(len > 0){
+ if(len > max_len){
+ len = max_len;
+ }
+ if((data = (char *)realloc(data, (len + 2) * sizeof(char)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ vsnprintf(data, (len + 1), fmt, args);
+ }
+va_end(args);
+
+return data;
+}
+
+
+
--- /dev/null
+// safe_strncat.c
+// $Id: safe_strncat.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<unistd.h>
+#include<stdarg.h>
+#include<fcntl.h>
+#include<sys/types.h>
+#include<sys/stat.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+
+
+char * safe_strncat(char * buf, char * newdata, int max_len)
+{
+int plen = 0;
+int newdata_count;
+int buf_count;
+
+if(newdata == NULL){
+ return buf;
+ }
+else if(newdata[0] == (char)0x00){
+ return buf;
+ }
+
+newdata_count = (int)strlen(newdata);
+
+if(buf == NULL){
+ buf = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+
+buf_count = (int)strlen(buf);
+
+if(buf_count < max_len){
+ if(max_len <= (newdata_count + buf_count)){
+ plen = max_len - buf_count;
+ if((buf = (char *)realloc(buf, sizeof(char) * (max_len + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(buf, newdata, (plen + 1));
+ fprintf(stderr,"data size err %s %d %d %d\n", buf, newdata_count, max_len, plen);
+ return buf;
+ }
+ if(max_len > (newdata_count + buf_count)){
+ if((buf = (char *)realloc(buf, sizeof(char) * (newdata_count + buf_count + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ mlexit();
+ }
+ strncat(buf, newdata, (newdata_count + 1));
+ #ifdef AL_DEBUG
+ printf("COUNT=<%d>GETDATA=<%s>\n", newdata_count, buf);
+ #endif
+ return buf;
+ }
+ }
+
+return buf;
+}
+
+
+
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "almemsys.h"
+
+
+
+char * safe_ujtoj(char * data)
+{
+char * swap;
+int max;
+// int count;
+
+max = (int)strlen(data);
+
+if(max > 0){
+ swap = (char *)calloc((max * 2), sizeof(char));
+ ujtoj((unsigned char *)swap, (unsigned char *)data);
+ data = safe_memcpy(data, swap, BUF_MAX);
+
+// for(count = 0; count < strlen(data); count++){
+// printf("data char[%c] data hex<0x%x>\n", data[count], data[count]);
+// }
+
+
+ free(swap);
+ }
+else{
+ fprintf(stderr,"safe_ujtoj(): data size err.\n");
+ }
+
+return data;
+}
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<arpa/inet.h>
+#include<stdlib.h>
+#include<string.h>
+#include<pthread.h>
+#include <errno.h>
+
+
+
+/*----------------------- CONNECT --------------------*/
+//int select_connect(int * sk, struct sockaddr_in * my_addr, int len, int timeout)
+int select_connect(int * sk, struct sockaddr_in * my_addr, int timeout)
+{
+int ret, retval;
+fd_set rfds;
+struct timeval tv;
+
+ret = 0;
+
+fcntl(* sk, F_SETFL, O_NONBLOCK);
+
+if((connect(*sk, (struct sockaddr *) my_addr, sizeof(* my_addr))) < 0){
+
+//if((ret = connect(* sk, (struct sockaddr *) my_addr, len)) < 0){
+// fprintf(stderr,"socket_connect(): Not connection\n");
+ fcntl(* sk, F_SETFL, 0);
+ return 0;
+ }
+
+if(ret >= 0){
+ fcntl(* sk, F_SETFL, 0);
+ return(ret);
+ }
+
+if(errno == EINPROGRESS){
+ tv.tv_sec = timeout;
+ tv.tv_usec = 0;
+ while(1){
+ FD_ZERO(&rfds);
+ FD_SET(* sk, &rfds);
+ retval = select(* sk + 1, NULL, &rfds, NULL, &tv);
+
+ if(retval < 0){
+ fcntl(* sk, F_SETFL, 0);
+ return(-1);
+ }
+ else if(retval == 0){
+ fcntl(* sk, F_SETFL, 0);
+ return(-1);
+ }
+ else{
+ fcntl(* sk, F_SETFL, 0);
+ return(ret);
+ }
+
+ }
+ }
+else{
+ fcntl(* sk, F_SETFL, 0);
+ return(-1);
+ }
+
+return(ret);
+}
+
+
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "almemsys.h"
+
+
+//char * select_fdcat(int sk, char * getdata, int * ret, int max, int interval);
+
+// #define SOCKET_RECVBUG
+
+
+char * select_fdcat(int sk, char * getdata, int * ret, int max, int interval)
+{
+struct timeval tv;
+int retval, getcount, indata, inlen, count, plen;
+char bf[BUF_DEFLEN];
+char * buf;
+
+buf = bf;
+indata = 0;
+inlen = 0;
+count = 0;
+plen = 0;
+
+#ifdef SOCKET_RECVBUG
+fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(1): interval time set %d \n", interval);
+#endif
+
+if(getdata == NULL){
+ getdata = (char *)calloc(BUF_LEN, sizeof(char));
+ }
+else{
+ getdata = null_free(getdata);
+ }
+
+
+fd_set rfds;
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+* ret = 0;
+getcount = 0;
+
+FD_ZERO(&rfds);
+FD_SET(sk, &rfds);
+
+
+retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+
+switch(retval){
+
+ case -1:
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(1) retval=%d line=%d file=%s err=%s\n",
+ retval, __LINE__, __FILE__, strerror(errno));
+ #endif
+ * ret = -1;
+ return getdata;
+ case 0:
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(2) retval=%d line=%d file=%s err=%s\n",
+ retval, __LINE__, __FILE__, strerror(errno));
+ #endif
+ * ret = -2;
+ return getdata;
+ default:
+
+ while(1){
+
+ indata = read(sk, buf, BUF_DEFLEN);
+
+ if(indata <= 0){
+ if(errno != 11 && errno != 25){
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr, "SOCKET_RECVBUG: select_fdcat(3): farst read err indata=%d\n", indata);
+ fprintf(stderr, "SOCKET_RECVBUG: select_fdcat(3-2): ERRNO: %d %s\n", errno, strerror(errno));
+ #endif
+ * ret = -3;
+ break;
+ }
+ else{
+ sleep(1);
+// #ifdef SOCKET_RECVBUG
+ fprintf(stderr, "SOCKET_RECVBUG: select_fdcat(4): ERRNO: %d %s\n", errno, strerror(errno));
+// #endif
+ getcount++;
+ if(getcount > 5){
+ * ret = -4;
+ break;
+ }
+ }
+ } // if
+ else{
+
+ buf[indata] = (char)0x00;
+
+ if(indata <= BUF_DEFLEN && indata > 0){
+
+ if(max >= (inlen + indata)){
+ inlen = inlen + indata;
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ exit(1);
+ }
+ strncat(getdata, buf, (indata + 1));
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ count = mem_count(getdata, (char)0x0a);
+ if(getdata[count] == (char)0x0a && count >= 0){
+ getdata[count+1] = (char)0x00;
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(5): (1nomall)CO=<%d>COALL=<%d>RIALCO=<%d>DATA=<%s>PO<%p><%d>\n",
+ indata, inlen, (int)strlen(getdata), getdata, getdata, count);
+ #endif
+ #ifdef SEND_RECV_BUG
+ fprintf(stderr,"RECV >> size=%d data=<%s>", strlen(getdata), getdata);
+ #endif
+ * ret = 1;
+ break;
+ }
+
+ }
+
+ if(max < (inlen + indata)){
+ plen = indata - (inlen - max);
+ inlen = max;
+ fprintf(stderr,"memory max count err. %d\n", inlen);
+ if((getdata = (char *)realloc(getdata, sizeof(char) * (inlen + 1)))==NULL){
+ fprintf(stderr,"The memory cannot be newly secured. \n");
+ exit(1);
+ }
+ strncat(getdata, buf, (plen + 1));
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ getdata[inlen - 1] = (char)0x0a;
+ getdata[inlen] = (char)0x00;
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(6): (1nomall)CO=<%d>COALL=<%d>RIALCO=<%d>DATA=<%s>PO<%p><%d>\n",
+ indata, inlen, (int)strlen(getdata), getdata, getdata, count);
+ #endif
+ while(1){
+ indata = read(sk, buf, BUF_DEFLEN);
+ if(indata == 0){
+ * ret = -5;
+ break;
+ }
+ count = mem_count(buf, (char)0x0a);
+ if(buf[count] == (char)0x0a && count >= 0){
+ fprintf(stderr,"data cut of buf over err. \n");
+ * ret = 2;
+ break;
+ }
+ clean_mem(buf, '\0', BUF_DEFLEN);
+ }
+ }
+ }
+
+
+ #ifdef SOCKET_RECVBUG
+ fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(7) ret=%d line=%d file=%s err=%s size=%d\n",
+ * ret, __LINE__, __FILE__, strerror(errno), strlen(getdata));
+ fprintf(stderr,"%s\n", getdata);
+ #endif
+ } // else
+
+ } // while
+
+ break;
+
+ } // switch
+
+
+// if(* ret >= 1 || * ret < 0){
+// break;
+// }
+// else{
+// #ifdef SOCKET_RECVBUG
+// fprintf(stderr,"SOCKET_RECVBUG: select_fdcat(8L) Loop Loop. ret=%d line=%d file=%s err=%s size=%d\n",
+// * ret, __LINE__, __FILE__, strerror(errno), strlen(getdata));
+// #endif
+// }
+
+
+return(getdata);
+}
+
+
+
+
+
+
--- /dev/null
+/* -- selef_convert_data() -- */
+/* -- 20120910 */
+
+#include <stdio.h>
+#include <string.h>
+#include <iconv.h>
+#include <errno.h>
+
+#include "almemsys.h"
+
+
+int self_convert_data(const char * input_code, const char * output_code, char * outbuf, size_t buf_size)
+{
+int ret;
+char inbuf[buf_size];
+
+memset(inbuf, 0x00, buf_size);
+memcpy(inbuf, outbuf, strlen(outbuf));
+
+ret = convert(input_code, output_code, inbuf, outbuf, buf_size);
+
+return ret;
+}
+
+
+
--- /dev/null
+// 固定長のデリミターカット
+// dataはlen分の長さが保証されていること
+
+#include<stdio.h>
+#include<string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "almemsys.h"
+
+
+int self_delim_get(char * swap, char * data, char delim, int target, int len)
+{
+int sto, sta, count, ret;
+sta =0;
+sto =0;
+count = 0;
+ret = 0;
+
+// delim の位置、データの大きさ
+count = delim_count(swap, delim, target, &sta, &sto);
+#ifdef MAIL_DEBUG
+printf("DELIM 1 %d -> %d %d\n", sta, sto, count);
+#endif
+if(count > 0 && sta <= sto && count < len){
+ ret = memcount_cpm(data, swap, sta, sto, len);
+ }
+else{
+ ret = -1;
+ }
+#ifdef MAIL_DEBUG
+printf("data =%s\n", data);
+#endif
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+// self_memcmp.c
+// $Id: self_memcmp.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+/* ----------- SELF MEMCMP ------------- */
+int self_memcmp(char * dataa, char * datab)
+{
+int ret, maxa, maxb;
+
+maxa = (int)strlen(dataa);
+maxb = (int)strlen(datab);
+
+if(maxa != maxb){
+ ret = -1;
+ return ret;
+ }
+else{
+ ret = memcmp(dataa, datab, maxa);
+ }
+
+// printf("SELF_MEMCMP ret<%d> <%s> <%s>\n", ret, dataa, datab);
+
+return ret;
+}
+
+
+
--- /dev/null
+// self_memcpy.c
+// $Id: self_memcpy.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+extern int count_memcpy(char *, char *, int);
+
+
+/* ----------- SELF MEMCPY ------------- */
+int self_memcpy(char * pan, char * data, int buf_size)
+{
+int ret;
+int data_len = strlen(data) - 1;
+
+ret = 0;
+memset(pan, 0x00, buf_size-1);
+
+if((buf_size -1) <= data_len ){
+ count_memcpy(pan, data, buf_size -1);
+// fprintf(stderr,"self_memcpy() %d %d->%s\n", buf_size, data_len, data);
+ ret = 0;
+ }
+else {
+ count_memcpy(pan, data, strlen(data)+1);
+ ret = 0;
+ }
+return(ret);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+/* ----------- SELF STRNCAT ------------- */
+int self_strncat(char * pan, char * data, int buf_size)
+{
+static int ret;
+int len1 = strlen(pan);
+int len2 = strlen(data)+1;
+
+ret = 0;
+if((buf_size-1) >= (len1 + len2)){
+ strncat(pan, data, len2);
+ }
+else {
+ fprintf(stderr,"size err self_strncat() %d %d->%s %d->%s\n", buf_size, len1, pan, len2, data);
+ }
+return(ret);
+}
+
--- /dev/null
+// set_mem.c
+// $Id: set_mem.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+
+
+
+/*------------------ SET MEM -------------------*/
+int set_mem( char data[], char chA, int count )
+{
+int inA=0;
+for(; inA < count; ){
+ if( data[inA] == chA ){
+ data[inA] = (char)0x00;
+ }
+ inA++;
+ }
+return inA;
+}
+
+
+
--- /dev/null
+
+
+
+
+
+#include <stdio.h>
+
+
+// 一つの32Bit整数に4つの8Bit整数を含めて取り出す
+// int main(void)
+// {
+// int bar = 0;
+// int ab = 0;
+// int abc = 0;
+// int abcd = 0;
+//
+// int a = 10;
+// int b = 20;
+// int c = 30;
+// int d = 40;
+//
+//
+// int mask_4 = 0xff000000;
+// int mask_3 = 0x00ff0000;
+// int mask_2 = 0x0000ff00;
+// int mask_1 = 0x000000ff;
+//
+// ab = ((a << 8) + b);
+// abc = ((ab << 8) + c);
+// abcd = ((abc << 8) + d);
+//
+//
+// printf("a = %d, b = %d, c = %d, d = %d, ab = %d, abc = %d, abcd = %d\n", a, b, c, d, ab, abc, abcd);
+// printf("ax = %x, bx = %x, cx = %x, dx = %x, abx = %x, abcx = %x, abcdx = %x\n", a, b, c, d, ab, abc, abcd);
+//
+// bar = ((abcd & mask_4) >> 24);
+// printf("mask4 %x: %d\n", bar, bar);
+//
+// bar = ((abcd & mask_3) >> 16);
+// printf("mask3 %x: %d\n", bar, bar);
+//
+// bar = ((abcd & mask_2) >> 8);
+// printf("mask2 %x: %d\n", bar, bar);
+//
+// bar = (abcd & mask_1);
+// printf("mask1 %x: %d\n", bar, bar);
+//
+// return 0;
+// }
+//
+
+
+int shift8_updown_in(int sh24, int sh16, int sh8, int sh0)
+{
+
+int ret = 0;
+int sha = 0;
+int shb = 0;
+
+if(sh24 >= 255){ sh24 = 254; }
+if(sh24 < 0){ sh24 = 0; }
+
+if(sh16 >= 255){ sh16 = 254; }
+if(sh16 < 0){ sh16 = 0; }
+
+if(sh8 >= 255){ sh8 = 254; }
+if(sh8 < 0){ sh8 = 0; }
+
+if(sh0 >= 255){ sh0 = 254; }
+if(sh0 < 0){ sh0 = 0; }
+
+
+sha = ((sh24 << 8) + sh16);
+shb = ((sha << 8) + sh8);
+ret = ((shb << 8) + sh0);
+
+return ret;
+}
+
+
+
+
+
+
+
+
+
--- /dev/null
+
+
+
+// 一つの32Bit整数に4つの8Bit整数を含めて取り出す
+// int main(void)
+// {
+// int bar = 0;
+// int ab = 0;
+// int abc = 0;
+// int abcd = 0;
+//
+// int a = 10;
+// int b = 20;
+// int c = 30;
+// int d = 40;
+//
+//
+// int mask_4 = 0xff000000;
+// int mask_3 = 0x00ff0000;
+// int mask_2 = 0x0000ff00;
+// int mask_1 = 0x000000ff;
+//
+// ab = ((a << 8) + b);
+// abc = ((ab << 8) + c);
+// abcd = ((abc << 8) + d);
+//
+//
+// printf("a = %d, b = %d, c = %d, d = %d, ab = %d, abc = %d, abcd = %d\n", a, b, c, d, ab, abc, abcd);
+// printf("ax = %x, bx = %x, cx = %x, dx = %x, abx = %x, abcx = %x, abcdx = %x\n", a, b, c, d, ab, abc, abcd);
+//
+// bar = ((abcd & mask_4) >> 24);
+// printf("mask4 %x: %d\n", bar, bar);
+//
+// bar = ((abcd & mask_3) >> 16);
+// printf("mask3 %x: %d\n", bar, bar);
+//
+// bar = ((abcd & mask_2) >> 8);
+// printf("mask2 %x: %d\n", bar, bar);
+//
+// bar = (abcd & mask_1);
+// printf("mask1 %x: %d\n", bar, bar);
+//
+// return 0;
+// }
+//
+
+
+
+
+
+#include <stdio.h>
+
+int shift8_updown_out(int base, char ch)
+{
+
+int mask_to = 0xff000000;
+int mask_mi = 0x00ff0000;
+int mask_up = 0x0000ff00;
+int mask_down = 0x000000ff;
+
+int ret = 0;
+
+if(base < 0){ base = 0; }
+
+// 32ビット整数を右に24ビットシフトした位置を0にして8ビット整数を読む
+if(ch == 't'){
+ ret = ((base & mask_to) >> 24);
+ }
+// 32ビット整数を右に16ビットシフトした位置を0にして8ビット整数を読む
+else if(ch == 'm'){
+ ret = ((base & mask_mi) >> 16);
+ }
+// 32ビット整数を右に8ビットシフトした位置を0にして8ビット整数を読む
+else if(ch == 'u'){
+ ret = ((base & mask_up) >> 8);
+ }
+else if(ch == 'd'){
+ ret = (base & mask_down);
+ }
+else{
+ ret = -1;
+ }
+
+return ret;
+}
+
+
+
+
+
+
+
+
+
--- /dev/null
+// tcp.c
+// $Id: tcp.c,v 1.3 2007/11/01 05:57:06 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<arpa/inet.h>
+#include<stdlib.h>
+#include<string.h>
+#include<pthread.h>
+#include <errno.h>
+
+
+/*--------------------- ACCEPT -------------------*/
+int socket_accept(struct sockaddr_in * my_addr, int *ls, int *sk)
+{
+static int ret;
+
+unsigned int my_addrlen = sizeof(* my_addr);
+
+ret = -1;
+if((*sk = accept(*ls, (struct sockaddr *) my_addr, &my_addrlen)) < 0){
+ fprintf(stderr,"socket_accept(): not scception ERRNO: %d %s\n", errno, strerror(errno));
+ close(*ls);
+ ret = -1;
+ return(ret);
+ exit(1);
+ }
+else {
+ ret = 0;
+ return(ret);
+ }
+return(ret);
+}
+
+
+
+
+
--- /dev/null
+
+#include<sys/types.h>
+#include<sys/socket.h>
+#include<netinet/in.h>
+#include<netdb.h>
+#include<stdio.h>
+#include<errno.h>
+#include<unistd.h>
+#include<string.h>
+#include<stdlib.h>
+#include<arpa/inet.h>
+
+#include"almemsys.h"
+
+// proto type
+// int socket_accept46(struct sockaddr_storage * from, fd_set rfd0, int * s, int smax, int sockmax);
+
+
+char * socket_accept46(char * ipdata, fd_set rfd, int * s, int smax, int sockmax, int * sk, int * net)
+{
+struct sockaddr_storage from;
+struct sockaddr_in * sin;
+struct sockaddr_in6 * sin6;
+char bu[256];
+char * buf = bu;
+
+int loopcount, n, i;
+// fd_set rfd;
+socklen_t fromlen;
+* net = 0;
+loopcount = 24;
+
+memset(&from, 0, sizeof(from));
+
+// rfd = * rfd0;
+
+n = select(sockmax + 1, &rfd, NULL, NULL, NULL);
+
+
+if(n < 0){
+ perror("select");
+ return ipdata;
+ }
+for(i = 0; i < smax; i++){
+ if(FD_ISSET(s[i], &rfd)){
+
+ fromlen = sizeof(from);
+ * sk = accept(s[i], (struct sockaddr *)&from, &fromlen);
+
+ if(from.ss_family == AF_INET){
+ sin = (struct sockaddr_in *)&from;
+ * net = 4;
+ ipdata = safe_memcpy(ipdata, (char *)inet_ntop(AF_INET, &(sin->sin_addr), buf, 256), BUF_LEN);
+ }
+ else if(from.ss_family == AF_INET6){
+ sin6 = (struct sockaddr_in6 *)&from;
+ * net = 6;
+ ipdata = safe_memcpy(ipdata, (char *)inet_ntop(AF_INET6, &(sin6->sin6_addr), buf, 256), BUF_LEN);
+ }
+ else{
+ * net = 0;
+ printf("not accepted connection fer v6 or v4\n");
+ }
+
+ fprintf(stderr,"accept to %d , %d\n", * sk, s[i]);
+
+ if(* sk < 0){
+ loopcount= loopcount - 1;
+ if(loopcount == 0){
+ exit(1);
+ }
+ continue;
+ }
+ else{
+ loopcount = 24;
+ }
+ }
+ }
+
+return ipdata;
+}
+
+
+
+
--- /dev/null
+
+#include<sys/types.h>
+#include<sys/socket.h>
+#include<netinet/in.h>
+#include<netdb.h>
+#include<stdio.h>
+#include<errno.h>
+#include<unistd.h>
+#include<string.h>
+#include<stdlib.h>
+#include<arpa/inet.h>
+
+
+// proto type
+// int socket_accept46rfd(fd_set * rfd, int * s, int smax);
+
+int socket_accept46rfd(fd_set * rfd, int * s, int smax)
+{
+int i;
+
+FD_ZERO(rfd);
+for(i = 0; i < smax; i++){
+ FD_SET(s[i], rfd);
+ }
+
+return 0;
+}
+
+
+
+
+
--- /dev/null
+// tcp.c
+// $Id: tcp.c,v 1.3 2007/11/01 05:57:06 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<arpa/inet.h>
+#include<stdlib.h>
+#include<string.h>
+#include<pthread.h>
+#include <errno.h>
+
+
+
+/*------------------ BIND ----------------------*/
+int socket_bind(struct sockaddr_in * my_addr, int port, char ip_addr[], int *ls)
+{
+int ret;
+ret = 0;
+
+if((*ls = socket(AF_INET, SOCK_STREAM, 0))==-1){
+ fprintf(stderr,"socket_bind(1): Not cleate socket\n");
+ return ret;
+ }
+
+my_addr->sin_family = AF_INET;
+my_addr->sin_port = htons(port);
+/* my_addr->sin_addr.s_addr = inet_addr(ip_addr); */
+if(0 == memcmp(ip_addr, "INADDR_ANY", 10)){
+ my_addr->sin_addr.s_addr = INADDR_ANY;
+ }
+else{
+ my_addr->sin_addr.s_addr = inet_addr(ip_addr);
+ }
+
+if(bind(*ls, (struct sockaddr *) my_addr, sizeof(* my_addr)) == -1){
+ fprintf(stderr,"socket_bind(2): Not cleate bind\n");
+ close(*ls);
+ return ret;
+ }
+
+if((listen(*ls,0))==-1){
+ fprintf(stderr,"socket_bind(3): Not listen port\n");
+ close(*ls);
+ return ret;
+ }
+
+return ret;
+}
+
+
+
+
+
--- /dev/null
+
+#include<sys/types.h>
+#include<sys/socket.h>
+#include<netinet/in.h>
+#include<netdb.h>
+#include<stdio.h>
+#include<errno.h>
+#include<unistd.h>
+#include<string.h>
+#include<stdlib.h>
+#include<arpa/inet.h>
+
+
+// proto type
+// int socket_bind46(struct addrinfo * hints, char * addr, char * port, int * ls, int maxsock);
+
+int socket_bind46(struct addrinfo * hints, char * addr, char * port, int * ls, int maxsock)
+{
+static struct addrinfo * res;
+static struct addrinfo * res0;
+
+int error;
+int smax;
+int sockmax;
+char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+
+#ifdef IPV6_V6ONLY
+const int on = 1;
+#endif
+
+
+error = getaddrinfo(addr, port, hints, &res0);
+if(error){
+ fprintf(stderr,"%s : %s: %s\n", addr, port, gai_strerror(error));
+ return -1;
+ }
+
+smax = 0;
+sockmax = -1;
+for(res = res0; res && smax < maxsock; res = res->ai_next){
+ ls[smax] = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+ if(ls[smax] < 0){
+ continue;
+ }
+ if(ls[smax] >= FD_SETSIZE){
+ close(ls[smax]);
+ ls[smax] = -1;
+ continue;
+ }
+#ifdef IPV6_V6ONLY
+ if(res->ai_family == AF_INET6 && setsockopt(ls[smax], IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0){
+ perror("setsockopt");
+ ls[smax] = -1;
+ continue;
+ }
+#endif
+ if(bind(ls[smax], res->ai_addr, res->ai_addrlen) < 0){
+ close(ls[smax]);
+ ls[smax] = -1;
+ continue;
+ }
+ if(listen(ls[smax], 5) < 0){
+ close(ls[smax]);
+ ls[smax] = -1;
+ continue;
+ }
+ error = getnameinfo(res->ai_addr, res->ai_addrlen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+ if(error){
+ fprintf(stderr,"test: %s\n", gai_strerror(error));
+ return -1;
+ }
+ fprintf(stderr,"listen to %s %s %d\n", hbuf, sbuf, ls[smax]);
+ if(ls[smax] > sockmax){
+ sockmax = ls[smax];
+ smax++;
+ }
+ } /* */
+
+return smax;
+}
+
+
+
+
--- /dev/null
+// tcp.c
+// $Id: tcp.c,v 1.3 2007/11/01 05:57:06 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<arpa/inet.h>
+#include<stdlib.h>
+#include<string.h>
+#include<pthread.h>
+#include <errno.h>
+
+
+
+/*----------------------- CONNECT --------------------*/
+int socket_connect(struct sockaddr_in * my_addr, int port, char ip_addr[], int *sk)
+{
+int ret;
+
+ret = 0;
+if((* sk = socket(AF_INET, SOCK_STREAM, 0))==-1){
+ fprintf(stderr,"socket_connect(): Not cleate socket\n");
+ ret = -1;
+ return(ret);
+ }
+
+my_addr->sin_family = AF_INET;
+my_addr->sin_port = htons(port);
+my_addr->sin_addr.s_addr = inet_addr(ip_addr);
+
+if(connect(*sk, (struct sockaddr *) my_addr, sizeof(* my_addr)) == -1){
+ fprintf(stderr,"socket_connect(): Not connection\n");
+ close(*sk);
+ ret = -1;
+ return(ret);
+ }
+
+return(ret);
+}
+
+
+
+
+
+
+
--- /dev/null
+
+#include<sys/types.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<netdb.h>
+#include<stdio.h>
+#include<errno.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<string.h>
+#include<stdlib.h>
+#include<arpa/inet.h>
+#include <errno.h>
+
+
+// int socket_connect46(struct addrinfo * hints, char * ip, char * port, int * sk);
+
+
+int socket_connect46(struct addrinfo * hints, char * ip, char * port, int * sk)
+{
+
+struct addrinfo *res, *res0;
+int ret;
+char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+int error;
+ret = -1;
+
+hints->ai_socktype = SOCK_STREAM;
+// hints->ai_socktype = SOCK_DGRAM; /* Datagram socket */
+hints->ai_flags = AI_PASSIVE; /* For wildcard IP address */
+hints->ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
+hints->ai_protocol = 0; /* Any protocol */
+hints->ai_canonname = NULL;
+hints->ai_addr = NULL;
+hints->ai_next = NULL;
+
+error = getaddrinfo(ip, port, hints, &res0);
+if(error){
+ fprintf(stderr, "ERR: %s %s: %s\n", ip, port, gai_strerror(error));
+ exit(1);
+ }
+
+for(res = res0; res; res = res->ai_next){
+ error = getnameinfo(res->ai_addr, res->ai_addrlen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+ if(error){
+ fprintf(stderr,"ERR: %s %s: %s\n", ip, port, gai_strerror(error));
+ continue;
+ }
+
+// fprintf(stderr,"trying %s port %s\n", hbuf, sbuf);
+
+ * sk = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+ if(* sk < 0){
+ fprintf(stderr,"ERR: %d\n", * sk);
+ continue;
+ }
+
+ if((ret = connect(* sk, res->ai_addr, res->ai_addrlen)) < 0){
+ close(* sk);
+ * sk = -1;
+ continue;
+ }
+ else{
+ return ret;
+ }
+ }
+
+fprintf(stderr,"ERR: test: no destination to connect to\n");
+exit(1);
+
+}
+
+
+
+
--- /dev/null
+
+#include<sys/types.h>
+#include<sys/socket.h>
+#include<netinet/in_systm.h>
+#include<netinet/in.h>
+#include<netinet/ip.h>
+#include<netdb.h>
+#include<stdio.h>
+#include<errno.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<string.h>
+#include<stdlib.h>
+#include<arpa/inet.h>
+#include <errno.h>
+
+#include"almemsys.h"
+
+// int socket_connect46(struct addrinfo * hints, char * ip, char * port, int * sk);
+
+
+int socket_connect46select(struct addrinfo * hints, char * ip, char * port, int * sk, int interval)
+{
+
+struct addrinfo *res, *res0;
+int ret;
+char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+int error;
+ret = -1;
+
+hints->ai_socktype = SOCK_STREAM;
+// hints->ai_socktype = SOCK_DGRAM; /* Datagram socket */
+hints->ai_flags = AI_PASSIVE; /* For wildcard IP address */
+hints->ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
+hints->ai_protocol = 0; /* Any protocol */
+hints->ai_canonname = NULL;
+hints->ai_addr = NULL;
+hints->ai_next = NULL;
+
+error = getaddrinfo(ip, port, hints, &res0);
+if(error){
+ fprintf(stderr, "ERR: %s %s: %s\n", ip, port, gai_strerror(error));
+ exit(1);
+ }
+
+for(res = res0; res; res = res->ai_next){
+ error = getnameinfo(res->ai_addr, res->ai_addrlen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+ if(error){
+ fprintf(stderr,"ERR: %s %s: %s\n", ip, port, gai_strerror(error));
+ continue;
+ }
+
+// fprintf(stderr,"trying %s port %s\n", hbuf, sbuf);
+
+ * sk = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+ if(* sk < 0){
+ fprintf(stderr,"ERR: %d\n", * sk);
+ continue;
+ }
+
+// FreeBSDにて問題があり、現在は検証中です、
+// if((ret = connect(* sk, res->ai_addr, res->ai_addrlen)) < 0){
+// if((ret = select_connect(sk, res->ai_addr, res->ai_addrlen, interval)) < 0){
+ if((ret = select_connect(sk, (struct sockaddr_in *)res->ai_addr, interval)) < 0){
+ close(* sk);
+ * sk = -1;
+ continue;
+ }
+ else{
+ return ret;
+ }
+ }
+
+fprintf(stderr,"ERR: test: no destination to connect to\n");
+exit(1);
+
+}
+
+
+
+
--- /dev/null
+// socket_read.c
+// $Id: socket_read.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+
+
+int socket_read(int sk, char * readdata, int getlen, int interval){
+struct timeval tv;
+int retval;
+int ret;
+fd_set rfds;
+
+fcntl(sk, F_SETFL, O_NONBLOCK);
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+
+#ifdef SOCKET_BUG
+printf("SOCKET: socket_read(1): interval time set %d\n", interval);
+#endif
+
+ret = 0;
+
+// ret = read(sk, readdata, getlen);
+
+while(1){
+ FD_ZERO(&rfds);
+ FD_SET(sk, &rfds);
+ retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+ if(retval < 0){
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(2): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval == 0){
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(3): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval >= 1){
+ ret = read(sk, readdata, getlen);
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(4): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ break;
+ }
+ } /* while */
+
+
+fcntl(sk, F_SETFL, 0);
+
+return(ret);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "almemsys.h"
+
+int socket_reada(int sk, char * readdata, int max){
+int ret, stat, count;
+char cha[64];
+
+memset(cha, 0x00, 64);
+
+ret = 0;
+stat = 0;
+count = 0;
+
+while(1){
+
+ stat = read(sk, cha, 63);
+
+ if(stat <= 0){
+ if(readdata[ret-1] == '\r' || readdata[ret-1] == '\n'){
+ break;
+ }
+ else{
+ if(count > 2){
+ break;
+ }
+ count++;
+ }
+ }
+ else{
+ count = 0;
+ strncat(readdata, cha, stat);
+
+ memset(cha, 0x00, 64);
+ ret = ret + stat;
+ if(ret > max - 63){
+ fprintf(stderr, "socket_reada(): read size err. max=%d\n", max);
+ break;
+ }
+ }
+ }
+
+return(ret);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "almemsys.h"
+
+// #define SOCKET_READBUG
+
+int socket_readas(int sk, char * readdata, int max, int interval, int mode){
+int ret, stat;
+char cha[64];
+
+struct timeval tv;
+int retval;
+fd_set rfds;
+
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+
+
+memset(cha, 0x00, 64);
+
+ret = 0;
+stat = 0;
+
+while(1){
+ FD_ZERO(&rfds);
+ FD_SET(sk, &rfds);
+
+ retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+
+ if(retval < 0){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET: socket_read(2): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval == 0){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET: socket_read(3): NG select. time out break <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval >= 1){
+
+ stat = read(sk, cha, 32);
+
+ #ifdef SOCKET_READBUG
+ printf("stat = %d string = %s front_char = %02x %02x %02x %02x\n", stat, cha, cha[0], cha[1], cha[2], cha[3]);
+ printf("rear_char = %02x %02x %02x\n",cha[stat -2], cha[stat -1], cha[stat]);
+ #endif
+
+ if(stat < 0){
+ #ifdef SOCKET_READBUG
+ printf("BREAK stat==0\n");
+ #endif
+ break;
+ }
+
+ if(stat == 0 && cha[0] == 0x00 && cha[1] == 0x00){
+ #ifdef SOCKET_READBUG
+ printf("BREAK stat==0 cha0=00 cha1=00\n");
+ #endif
+ break;
+ }
+
+ if(stat == 1 && cha[0] == 0x0a && cha[1] == 0x00){
+ #ifdef SOCKET_READBUG
+ printf("BREAK stat==1 cha0=0a cha1=00\n");
+ #endif
+ break;
+ }
+
+ if(stat >= 2){
+ if(mode == 1){
+ if(cha[stat - 1] == 0x0a){
+ #ifdef SOCKET_READBUG
+ printf("BREAK stat>1 0d [mode 1]\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ break;
+ }
+ }
+ if(cha[stat - 2] == 0x0d && cha[stat - 1] == 0x0a){
+ #ifdef SOCKET_READBUG
+ printf("BREAK stat>1 0d 0a\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ break;
+ }
+ else{
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ if(ret > max - 32){
+ #ifdef SOCKET_READBUG
+ fprintf("socket_reada(): read size err.\n");
+ #endif
+ break;
+ }
+ }
+
+ }
+ }
+ } // while()
+
+return(ret);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <sys/select.h>
+
+#include<pthread.h>
+
+#include "almemsys.h"
+
+// #define SOCKET_READBUG
+
+
+// t1
+int read_check_th(struct th_str * th_struct)
+{
+int co;
+co = 0;
+th_struct->t1 = pthread_self();
+
+for(; th_struct->th_out < th_struct->th_timeout; ){
+
+ usleep(1000);
+ co++;
+ if( co >= 1000 ){
+ th_struct->th_out++;
+ co = 0;
+ }
+
+ safe_pthread_mutex_lock(&th_struct->read_mutex);
+ if(1 == th_struct->th_ret){
+ pthread_mutex_unlock(&th_struct->read_mutex);
+ break;
+ }
+ pthread_mutex_unlock(&th_struct->read_mutex);
+
+ if(th_struct->th_out >= th_struct->th_timeout){
+
+ safe_pthread_mutex_lock(&th_struct->read_mutex);
+ th_struct->th_ret = -1;
+ pthread_mutex_unlock(&th_struct->read_mutex);
+
+ close(th_struct->th_sk);
+ break;
+ }
+ }
+
+return 0;
+}
+
+
+
+// t2
+int read_get_th(struct th_str * th_struct)
+{
+int stat;
+
+stat = read(th_struct->th_sk, th_struct->th_cha, 32);
+th_struct->th_stat = stat;
+th_struct->th_count = th_struct->th_count + stat;
+
+//printf("========%d==%d======== %s \n", stat, th_struct->th_count, th_struct->th_cha);
+
+// CLOSEされてない場合はret = 1
+safe_pthread_mutex_lock(&th_struct->read_mutex);
+if(th_struct->th_ret == -1){
+ th_struct->th_stat = -2;
+ }
+else{
+ th_struct->th_ret = 1;
+ }
+pthread_mutex_unlock(&th_struct->read_mutex);
+
+return 0;
+}
+
+
+
+
+int socket_readasth(int sk, char * readdata, int max, int interval, int mode, int * size)
+{
+int ret, stat;
+char cha[64 + 3];
+
+// read() 用thread構造体の宣言
+// th_str は、almemsys.h 内で定義
+struct th_str * th_struct;
+struct th_str th_s;
+int tret;
+
+struct timespec tsv;
+// struct timeval tv;
+
+int retval;
+fd_set rfds;
+
+// tv.tv_sec = interval;
+// tv.tv_usec = 0;
+tsv.tv_sec = interval;
+tsv.tv_nsec = 0;
+
+memset(&th_s, 0x00, sizeof(th_s));
+th_struct = &th_s;
+
+tret = 0;
+th_struct->th_ret = 0;
+th_struct->th_out = 0;
+th_struct->th_count = 0;
+th_struct->th_sk = sk;
+th_struct->th_timeout = interval;
+
+memset(cha, 0x00, 64);
+ret = 0;
+stat = 0;
+
+
+while(1){
+ FD_ZERO(&rfds);
+ FD_SET(sk, &rfds);
+
+// retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+ retval = pselect(sk + 1, &rfds, NULL, NULL, &tsv, NULL);
+
+ if(retval < 0){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(1): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ else if(retval == 0){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(2): NG select. time out break <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -2;
+ break;
+ }
+ else{
+
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(3): OK select. break <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+
+ pthread_mutex_init(&th_struct->read_mutex, NULL);
+
+ memset(th_struct->th_cha, 0x00, 64);
+ th_struct->th_stat = 1024;
+ if((tret = pthread_create(&th_struct->t1, NULL, (void *)read_check_th, (long int *)th_struct)) != 0){
+ fprintf(stderr,"PTHERAD_ERR: socket_readasth(): pthread_create(read_check_th): %d %d\n",tret, errno);
+ }
+ if((tret = pthread_create(&th_struct->t2, NULL, (void *)read_get_th, (long int *)th_struct)) != 0){
+ fprintf(stderr,"PTHREAD_ERR: socket_readasth(): pthread_create(read_get_th): %d %d\n",tret, errno);
+ }
+
+ pthread_join( th_struct->t1, NULL);
+ pthread_join( th_struct->t2, NULL);
+
+ pthread_mutex_destroy(&th_struct->read_mutex);
+
+ stat = th_struct->th_stat;
+ self_memcpy(cha, th_struct->th_cha, 64);
+
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(5): ===== addr = %d =====read_get_th()===th_struct->th_ret=%d ===th_struct->th_stat=%d data = <%s>\n",
+ (int)&th_struct, th_struct->th_ret, th_struct->th_stat, cha);
+ #endif
+
+
+ #ifdef SOCKET_READBUG
+ printf("SOCKE_READBUG: socket_readasth(6): stat = %d string = %s front_char = %02x %02x %02x %02x\n", stat, cha, cha[0], cha[1], cha[2], cha[3]);
+ printf("rear_char = %02x %02x %02x\n",cha[stat -2], cha[stat -1], cha[stat]);
+ #endif
+
+ if(stat < 0){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socke_readasth(7): BREAK stat==0\n");
+ #endif
+ ret = stat;
+ break;
+ }
+
+ if(stat == 0 && cha[0] == 0x00 && cha[1] == 0x00){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(8): BREAK stat==0 cha0=00 cha1=00\n");
+ #endif
+ break;
+ }
+
+ if(stat == 1 && cha[0] == 0x0a && cha[1] == 0x00){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(9): BREAK stat==1 cha0=0a cha1=00\n");
+ #endif
+ break;
+ }
+
+ if(stat >= 2){
+ if(mode == 1){
+ if(cha[stat - 1] == 0x0a){ // if if 優先あり
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(10): BREAK -1=0d [mode 1]\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ break;
+ }
+
+ if(cha[stat - 2] == 0x0d && cha[stat - 1] == 0x0a){ // if if 優先順位あり
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(11): BREAK -2=0d -1=0a [mode 1]\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ break;
+ }
+ else{
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(12): BREAK else [mode 1]\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ if(ret > max - 32){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(13): read size err [mode 1].\n");
+ #endif
+ break;
+ }
+ }
+ }
+ else if(mode == 0){
+ if(cha[stat - 2] == 0x0d && cha[stat - 1] == 0x0a){ // if if 優先順位あり
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(14): BREAK -2=0d -1=0a [mode 0]\n");
+ #endif
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ break;
+ }
+ else{
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ if(ret > max - 32){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(15): read size err [mode 0].\n");
+ #endif
+ break;
+ }
+ }
+ }
+ else{
+ strncat(readdata, cha, stat);
+ memset(cha, 0x00, 33);
+ ret = ret + stat;
+ if(ret > max - 32){
+ #ifdef SOCKET_READBUG
+ printf("SOCKET_READBUG: socket_readasth(16): read size err [mode else].\n");
+ #endif
+ break;
+ }
+ }
+ }
+ }
+ } // while()
+
+// printf("almemsys(): socket_readasth(): count = %d\n", th_struct->th_count);
+
+
+* size = th_struct->th_count;
+
+return(ret);
+}
+
+
+
--- /dev/null
+// socket_read.c
+// $Id: socket_reads.c,v 1.1 2007/10/17 10:57:56 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+
+
+int socket_reads(int sk, char * readdata, int getlen, int interval){
+struct timeval tv;
+int retval;
+int ret;
+fd_set rfds;
+
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+
+#ifdef SOCKET_BUG
+printf("SOCKET: socket_read(1): interval time set %d\n", interval);
+#endif
+
+ret = 0;
+
+while(1){
+ FD_ZERO(&rfds);
+ FD_SET(sk, &rfds);
+ retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+ if(retval < 0){
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(2): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval == 0){
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(3): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break;
+ }
+ if(retval >= 1){
+ ret = read(sk, readdata, getlen);
+ #ifdef SOCKET_BUG
+ printf("SOCKET: socket_read(4): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ break;
+ }
+ } /* while */
+
+return(ret);
+}
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include"almemsys.h"
+
+// #define SOCKET_SENDBUG
+
+int socket_send(int sk, char * senddata, int interval)
+{
+int retval, flag, ret, co;
+struct timeval tv;
+fd_set wfds;
+
+// インターバルの設定
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+ret = 0;
+co = 0;
+
+// 非同期開始
+flag=fcntl(sk, F_GETFL, 0);
+fcntl(sk, F_SETFL, flag|O_NONBLOCK);
+
+for(co =0; co < 20; co++){
+ if((ret = send(sk, senddata, (int)strlen(senddata), 0)) < 0){
+ // sendがエラーを返す
+ if(errno == EAGAIN || errno == EWOULDBLOCK){
+ // リソースなエラーの場合
+ FD_ZERO(&wfds);
+ FD_SET(sk, &wfds);
+ // 書けるかのselectでFD変化を待つ
+ retval = select(sk + 1, NULL, &wfds, NULL, &tv);
+ if(retval < 0){
+ // select失敗
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(1): select失敗\n");
+ #endif
+ // 同期通信に戻す終了
+ fcntl(sk, F_SETFL, 0);
+ return -3;
+ }
+ else if(retval == 0){
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(2): select タイムアウト\n");
+ #endif
+ // selectタイムアウト
+ // 同期通信に戻す終了
+ fcntl(sk, F_SETFL, 0);
+ return -2;
+ }
+ else{
+ // 時間内にselect通過もういちど送信 forで10回繰り返す
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(3): select 通過、もう一度カキコ co=%d\n", co);
+ #endif
+ }
+ }
+ else{
+ // リソースエラー意外のエラー
+ // 同期通信に戻す終了
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(4): リソース意外のエラー %s\n", strerror(errno));
+ #endif
+ fcntl(sk, F_SETFL, 0);
+ return -1;
+ }
+ }
+ else{
+ // sendが素直に終了
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(5): sendが素直に終了 %d\n", ret);
+ #endif
+ fcntl(sk, F_SETFL, 0);
+ return ret;
+ }
+ usleep(200000);
+ } // for()
+
+
+#ifdef SOCKET_SENDBUG
+printf("SOCKET_SENDBUG: socket_send(6): 繰り返し回数超過 %d\n", co);
+#endif
+
+// 同期通信に戻す
+fcntl(sk, F_SETFL, flag);
+return -4;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include"almemsys.h"
+
+// #define SOCKET_SENDBUG
+
+int socket_send2(int sk, char * senddata, int interval, int * eno)
+{
+int retval, flag, ret, co;
+struct timeval tv;
+fd_set wfds;
+
+// インターバルの設定
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+ret = 0;
+co = 0;
+
+// 非同期開始
+flag=fcntl(sk, F_GETFL, 0);
+fcntl(sk, F_SETFL, flag|O_NONBLOCK);
+
+for(co =0; co < 20; co++){
+ if((ret = send(sk, senddata, (int)strlen(senddata), 0)) < 0){
+ * eno = errno;
+ // sendがエラーを返す
+ if(errno == EAGAIN || errno == EWOULDBLOCK){
+ // リソースなエラーの場合
+ FD_ZERO(&wfds);
+ FD_SET(sk, &wfds);
+ // 書けるかのselectでFD変化を待つ
+ retval = select(sk + 1, NULL, &wfds, NULL, &tv);
+ if(retval < 0){
+ // select失敗
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(1): select失敗\n");
+ #endif
+ // 同期通信に戻す終了
+ * eno = errno;
+ fcntl(sk, F_SETFL, 0);
+ return -3;
+ }
+ else if(retval == 0){
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(2): select タイムアウト\n");
+ #endif
+ // selectタイムアウト
+ // 同期通信に戻す終了
+ * eno = errno;
+ fcntl(sk, F_SETFL, 0);
+ return -2;
+ }
+ else{
+ // 時間内にselect通過もういちど送信 forで10回繰り返す
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(3): select 通過、もう一度カキコ co=%d\n", co);
+ #endif
+ * eno = errno;
+ }
+ }
+ else{
+ // リソースエラー意外のエラー
+ // 同期通信に戻す終了
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(4): リソース意外のエラー %s\n", strerror(errno));
+ #endif
+ * eno = errno;
+ fcntl(sk, F_SETFL, 0);
+ return -1;
+ }
+ }
+ else{
+ // sendが素直に終了
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET_SENDBUG: socket_send(5): sendが素直に終了 %d\n", ret);
+ #endif
+ * eno = errno;
+ fcntl(sk, F_SETFL, 0);
+ return ret;
+ }
+ usleep(200000);
+ } // for()
+
+
+//#ifdef SOCKET_SENDBUG
+printf("SOCKET_SENDBUG: socket_send(6): 繰り返し回数超過 %d %s\n", co, strerror(errno));
+//#endif
+
+// 同期通信に戻す
+* eno = errno;
+fcntl(sk, F_SETFL, flag);
+return -4;
+}
+
+
+
+
+
--- /dev/null
+// socket_sends.c
+// $Id: socket_sends.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+
+int socket_sends(int sk, char * senddata, int interval, char mode){
+static int ret;
+struct timeval tv;
+int retval;
+fd_set rfds;
+
+fcntl(sk, F_SETFL, O_NONBLOCK);
+tv.tv_sec = interval;
+tv.tv_usec = 0;
+
+if(mode > 1 || mode < 0){
+ mode = 0;
+ }
+
+#ifdef SOCKET_SENDBUG
+printf("SOCKET: socket_send(1): interval time set %d \n", interval);
+#endif
+
+ret = 0;
+
+ret = send(sk, senddata, (int)strlen(senddata), 0);
+
+while(1){
+ FD_ZERO(&rfds);
+ FD_SET(sk, &rfds);
+ retval = select(sk + 1, &rfds, NULL, NULL, &tv);
+ if(retval < 0){
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET: socket_send(2): NG select <%d> ERRNO: %d %s\n",
+ retval, errno, strerror(errno));
+ #endif
+ ret = -1;
+ break; }
+ if(retval == 0){
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET: socket_send(3): NG select <%d> ERRNO: %d %s ret=%d\n",
+ retval, errno, strerror(errno), ret);
+ #endif
+ if(mode == 0){
+ ret = -1;
+ }
+ break;
+ }
+ if(retval >= 1){
+ #ifdef SOCKET_SENDBUG
+ printf("SOCKET: socket_send(4): NG select <%d> ERRNO: %d %s ret=%d\n",
+ retval, errno, strerror(errno), ret);
+ #endif
+ break;
+ }
+ } /* while */
+
+
+fcntl(sk, F_SETFL, 0);
+
+return(ret);
+}
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+
+
+/*------------------ SWAP MEM -------------------*/
+int swap_armem( char data[], char chA, char chB, int sta, int sto)
+{
+int inA, ret, count;
+inA = 0;
+ret = 0;
+
+count = (int)strlen(data);
+
+if(0 < count && sta > 0 && sto <= count && sta < sto){
+ for(inA = sta; inA <= sto; ){
+ if( data[inA] == chA ){
+ data[inA] = chB;
+ ret++;
+ }
+ inA++;
+ }
+ }
+
+return(ret);
+}
+
+
--- /dev/null
+// swap_mem.c
+// $Id: swap_mem.c,v 1.1.1.1 2007/09/19 05:49:54 sendan Exp $
+// masashi shimakura
+
+#include<stdio.h>
+#include<string.h>
+
+
+/*------------------ SWAP MEM -------------------*/
+int swap_mem( char data[], char chA, char chB )
+{
+int inA, ret, count;
+inA = 0;
+ret = 0;
+
+count = (int)strlen(data);
+
+if(0 < count){
+ for(; inA < count; ){
+ if( data[inA] == chA ){
+ data[inA] = chB;
+ ret++;
+ }
+ inA++;
+ }
+ }
+
+return(ret);
+}
+
+
--- /dev/null
+
+
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+
+#include "almemsys.h"
+
+
+
+// 文字列全体の中のすべてのchS(char)を、(\r\n)の改行に置き換える。
+char * swap_rn(char *data, char chS)
+{
+char * swap;
+int max, count, count1, count2;
+int nlen = 0;
+count1 = 0;
+max = strlen(data);
+
+for(count2 = 0; count2 < max; count2++){
+ if(data[count2] == chS){
+ nlen++;
+ }
+ }
+
+if((swap = (char *)calloc(BUF_DEFLEN, sizeof(char)))==NULL){exit(1);}
+
+if(nlen > 0){
+ if((swap = (char*)realloc(swap, sizeof(char) * (max + nlen + 1)))==NULL){
+ fprintf(stderr,"swap_rn(): The memory cannot be newly secured. \n");
+ exit(1);
+ }
+
+ for(count = 0; count < max; count++){
+ if(data[count] == chS){
+ swap[count1] = '\r';
+ count1++;
+ swap[count1] = '\n';
+ count1++;
+ }
+ else {
+ swap[count1] = data[count];
+ count1++;
+ }
+ }
+ swap[count1] = (char)0x00;
+ clean_mem(data, '\0', (int)strlen(data));
+ data = safe_memcpy(data, swap, BUF_MAX);
+
+ }
+
+free(swap);
+
+return data;
+}
+
+
+
+
--- /dev/null
+#include<stdio.h>
+#include<time.h>
+
+#include "almemsys.h"
+
+
+char * time_getr(char * buf)
+{
+time_t t;
+struct tm tmbuf;
+
+t = time(NULL);
+localtime_r(&t, &tmbuf);
+
+buf = safe_sprintf(buf, BUF_MAX,"%04d:%02d:%02d:%02d:%02d:%02d",
+ tmbuf.tm_year + 1900,
+ tmbuf.tm_mon + 1,
+ tmbuf.tm_mday,
+ tmbuf.tm_hour,
+ tmbuf.tm_min,
+ tmbuf.tm_sec);
+
+return buf;
+}
+
+
+
+
--- /dev/null
+
+
+
+
+// cha 単位で t 時 から mt 時間引いた時間を返す関数 0 - 1 = 23
+int time_minus(int t, int mt, char cha)
+{
+int an, minu;
+an = 0;
+minu = 0;
+
+switch(cha){
+ case 'h': minu = 24;
+ break;
+ case 'i': minu = 60;
+ break;
+ default : minu = 12;
+ break;
+ }
+
+if(t >= minu){ t = 0; }
+if(t <= 0){ t = 0; }
+if(mt >= minu){ mt = 0; }
+if(mt <= 0){ mt = 0; }
+
+if(t == 0 && mt <= minu){
+ an = minu - mt;
+ }
+else if(t > 0 && mt <= t){
+ an = t - mt;
+ }
+else if(t > 0 && mt > t){
+ an = minu - (mt - t);
+ }
+
+if(an == minu){
+ an = 0;
+ }
+
+return an;
+}
+
+
+
--- /dev/null
+
+
+
+
+// cha 単位で t 時 と mt 時間足したプラス時間を返す関数 24 + 1 = 1
+int time_plas(int t, int pt, char cha)
+{
+int an, ans, plas;
+an = 0;
+ans = 0;
+plas = 1;
+
+switch(cha){
+ case 'h': plas = 23;
+ break;
+ case 'i': plas = 59;
+ break;
+ default : plas = 11;
+ break;
+ }
+
+// 23 - 0
+if(t == plas){
+ t = plas;
+ }
+if(t > plas){
+ t = 0;
+ }
+if(t <= 0){
+ t = 0;
+ }
+
+// 23 - 0
+if(pt == plas){
+ pt = plas;
+ }
+if(pt > plas){
+ pt = 0;
+ }
+if(pt <= 0){
+ pt = 0;
+ }
+
+an = t + pt;
+ans = an % plas;
+
+
+// printf("start = %d stop = %d plas = %d amari = %d\n", t, pt, an, ans);
+
+return ans;
+}
+
+
+
+
+
--- /dev/null
+
+#include<stdio.h>
+#include<string.h>
+
+
+
+/* ujtoj komata mitsuyuki著 TCP_IP ネットワークプログラミング引用 */
+
+#define iseuckanji(c) (0xa1<=(unsigned char)(c&0xff) && (unsigned char)(c&0xff)<=0xfe)
+#define iseuckana(c) (0x8e==(unsigned char)(c&0xff))
+
+
+/* ---- for test ---
+int chcode(char * data)
+{
+int count, max;
+count = 0;
+max = strlen(data);
+for(count = 0; count < max; count++){
+ printf("0x0%x,", data[count]);
+ }
+return max;
+}
+
+
+int main(int argc, char ** argv)
+{
+char Out[1024];
+char * out = Out;
+char * in = "これこれしかじか";
+
+ujtoj((unsigned char *)out, (unsigned char *)in);
+
+printf("in data <%s>\n", in);
+chcode(in);
+printf("out data <%s>\n", out);
+chcode(out);
+
+return 0;
+}
+*/
+
+
+/* EUC -> JIS */
+int ujtoj(unsigned char *to, unsigned char *from)
+{
+register int i, len, c;
+int kanji_flag;
+
+len = (int)strlen((char *)from);
+c = 0;
+kanji_flag = 0;
+
+for(i = 0; i < len; i++){
+ if(iseuckanji(from[i])){
+ if(kanji_flag == 0){
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x24;
+ c++;
+ to[c] = 0x42;
+ c++;
+ kanji_flag = 1;
+ }
+ to[c] = (from[i]&0x7f);
+ c++;
+ to[c] = (from[i+1]&0x7f);
+ c++;
+ i++;
+ }
+ else{
+ if(kanji_flag == 1){
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x28;
+ c++;
+ to[c] = 0x4a;
+ c++;
+ kanji_flag = 0;
+ }
+ to[c] = from[i];
+ c++;
+ }
+ }
+
+if(kanji_flag == 1){
+ to[c] = 0x1b;
+ c++;
+ to[c] = 0x28;
+ c++;
+ to[c] = 0x4a;
+ c++;
+ kanji_flag = 0;
+ }
+
+to[c] = '\0';
+
+return 0;
+}
+
+
+
+
+
--- /dev/null
+// unlinkdir.c
+// $Id: $
+// masashi shimakura
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<sys/types.h>
+#include<dirent.h>
+#include<unistd.h>
+#include"almemsys.h"
+
+
+
+/* --------- FILE COPY -------- */
+int unlinkdir(char * dirpath)
+{
+int ret, stat;
+DIR * dp;
+struct dirent * dirstat;
+
+char * filename = (char *)calloc(5, sizeof(char));
+
+ret = 0;
+stat = 0;
+
+if((dp = opendir(dirpath))!=NULL){
+
+ for( ;(dirstat = readdir(dp))!=(struct dirent *)NULL; ){
+
+ if(0 != self_memcmp(dirstat->d_name, ".")){
+ if(0 != self_memcmp(dirstat->d_name, "..")){
+ filename = safe_memcpy(filename, dirpath, BUF_MAX);
+ filename = safe_strncat(filename, "/", BUF_MAX);
+ filename = safe_strncat(filename, dirstat->d_name, BUF_MAX);
+ stat = unlink(filename);
+ if(stat < 0){
+ fprintf(stderr,"unlinkdir(): not delete file name. <%s>\n", filename);
+ ret = ret - 1;
+ }
+ else{
+ #ifdef UNLINK_DIR
+ fprintf(stderr,"unlinkdir(): delete file. <%s>\n", filename);
+ #endif
+ }
+ }
+ }
+ }
+
+ closedir(dp);
+ }
+else {
+ fprintf(stderr,"unlinkdir(): open dir. <%s>\n", dirpath);
+ ret = -1;
+ }
+
+free(filename);
+return(ret);
+}
+
+
+
--- /dev/null
+#include<stdio.h>
+#include<time.h>
+
+#include "almemsys.h"
+
+/* UNIX時間から時間日付等を返す (thread safe) */
+
+int utime_getr(time_t tt, char ch)
+{
+time_t t;
+struct tm tmbuf;
+
+t = tt;
+localtime_r(&t, &tmbuf);
+
+switch(ch){
+ case 'y': return(tmbuf.tm_year + 1900);
+ case 'm': return(tmbuf.tm_mon + 1);
+ case 'd': return(tmbuf.tm_mday);
+ case 'w': return(tmbuf.tm_wday);
+ case 'h': return(tmbuf.tm_hour);
+ case 'i': return(tmbuf.tm_min);
+ case 's': return(tmbuf.tm_sec);
+ default : return(0); break;
+ }
+
+return -1;
+}
+
+
+
OSDN Git Service
