char *richacl_mask_to_text(unsigned int mask, int fmt)
{
struct string_buffer *buffer;
char *str = NULL;
buffer = alloc_string_buffer(16);
if (!buffer)
return NULL;
write_mask(buffer, mask, fmt);
if (string_buffer_okay(buffer)) {
str = realloc(buffer->buffer, buffer->offset + 1);
if (str)
buffer->buffer = NULL;
} else
errno = ENOMEM;
free_string_buffer(buffer);
return str;
}
/*
* get the next match from the current position,
* throught the dictionary.
* this will return all the matchs.
*
* @return friso_array_t that contains all the matchs.
*/
__STATIC_API__ friso_array_t get_next_match( friso_t friso, friso_task_t task, uint_t idx ) {
register uint_t t;
string_buffer_t sb = new_string_buffer_with_string( task->buffer );
//create a match dynamic array.
friso_array_t match = new_array_list_with_opacity( friso->max_len );
array_list_add( match, friso_dic_get( friso->dic, __LEX_CJK_WORDS__, task->buffer ) );
for ( t = 1; t < friso->max_len
&& ( task->bytes = read_next_word( task, &idx, task->buffer ) ) != 0; t++ ) {
task->unicode = get_utf8_unicode( task->buffer );
if ( utf8_whitespace( task->unicode ) ) break;
if ( ! utf8_cjk_string( task->unicode ) ) break;
//append the task->buffer to the buffer.
string_buffer_append( sb, task->buffer );
//check the CJK dictionary.
if ( friso_dic_match( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) ) {
/*
* add the lex_entry_t insite.
* here is a key point:
* we use friso_dic_get function to get the address of the lex_entry_cdt
* that store in the dictionary, not create a new lex_entry_cdt.
* so :
* 1.we will not bother to the allocations of the newly created lex_entry_cdt.
* 2.more efficient of course.
*/
array_list_add( match, friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) );
}
}
/*buffer allocations clear*/
free_string_buffer( sb );
//array_list_trim( match );
return match;
}
//get the next cjk word from the current position, with simple mode.
__STATIC_API__ friso_hits_t next_simple_cjk( friso_t friso, friso_task_t task ) {
uint_t t, idx = task->idx, __length__;
string_buffer_t sb = new_string_buffer_with_string( task->buffer );
lex_entry_t e = friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer );
/*
* here bak the e->length in the task->hits->type.
* we will use it to count the task->idx.
* for the sake of use less variable.
*/
__length__ = e->length;
for ( t = 1;
t < friso->max_len
&& ( task->bytes = read_next_word( task, &idx, task->buffer ) ) != 0; t++ ) {
task->unicode = get_utf8_unicode( task->buffer );
if ( utf8_whitespace( task->unicode ) ) break;
if ( ! utf8_cjk_string( task->unicode ) ) break;
string_buffer_append( sb, task->buffer );
//check the existence of the word by search the dictionary.
if ( friso_dic_match( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) ) {
e = friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer );
}
}
//correct the offset of the segment.
task->idx += ( e->length - __length__ );
free_string_buffer( sb ); //free the buffer
//reset the hits.
task->hits->word = e->word;
task->hits->type = __FRISO_SYS_WORDS__;
return task->hits;
}
/*
* load the lexicon configuration file.
* and load all the valid lexicon from the configuration file.
*
* @param friso friso instance
* @param config friso_config instance
* @param _path dictionary directory
* @param _limitts words length limit
*/
FRISO_API void friso_dic_load_from_ifile(
friso_t friso,
friso_config_t config,
fstring _path,
uint_t _limits )
{
//1.parse the configuration file.
FILE *__stream;
char __chars__[1024], __key__[30], *__line__;
uint_t __length__, i, t;
friso_lex_t lex_t;
string_buffer_t sb;
//get the lexicon configruation file path
sb = new_string_buffer();
string_buffer_append( sb, _path );
string_buffer_append( sb, __FRISO_LEX_IFILE__ );
//printf("%s\n", sb->buffer);
if ( ( __stream = fopen( sb->buffer, "rb" ) ) != NULL )
{
while ( ( __line__ =
file_get_line( __chars__, __stream ) ) != NULL )
{
//comment filter.
if ( __line__[0] == '#' ) continue;
if ( __line__[0] == '\0' ) continue;
__length__ = strlen( __line__ );
//item start
if ( __line__[ __length__ - 1 ] == '[' )
{
//get the type key
for ( i = 0; i < __length__
&& ( __line__[i] == ' ' || __line__[i] == '\t' ); i++ );
for ( t = 0; i < __length__; i++,t++ ) {
if ( __line__[i] == ' '
|| __line__[i] == '\t' || __line__[i] == ':' ) break;
__key__[t] = __line__[i];
}
__key__[t] = '\0';
//get the lexicon type
lex_t = get_lexicon_type_with_constant(__key__);
if ( lex_t == -1 ) continue;
//printf("key=%s, type=%d\n", __key__, lex_t );
while ( ( __line__ = file_get_line( __chars__, __stream ) ) != NULL )
{
//comments filter.
if ( __line__[0] == '#' ) continue;
if ( __line__[0] == '\0' ) continue;
__length__ = strlen( __line__ );
if ( __line__[ __length__ - 1 ] == ']' ) break;
for ( i = 0; i < __length__
&& ( __line__[i] == ' ' || __line__[i] == '\t' ); i++ );
for ( t = 0; i < __length__; i++,t++ ) {
if ( __line__[i] == ' '
|| __line__[i] == '\t' || __line__[i] == ';' ) break;
__key__[t] = __line__[i];
}
__key__[t] = '\0';
//load the lexicon item from the lexicon file.
string_buffer_clear( sb );
string_buffer_append( sb, _path );
string_buffer_append( sb, __key__ );
//printf("key=%s, type=%d\n", __key__, lex_t);
friso_dic_load( friso, config, lex_t, sb->buffer, _limits );
}
}
} //end while
fclose( __stream );
} else {
printf("Warning: Fail to open the lexicon configuration file %s\n", sb->buffer);
}
free_string_buffer(sb);
}
int ssh2_auth(const char *hostip,
const char *username,
const char *password,
char **errmsg)
{
unsigned long hostaddr;
int sock;
struct sockaddr_in sin;
LIBSSH2_SESSION *session;
int rc;
LIBSSH2_KNOWNHOSTS *nh;
struct StringBuffer *sberrmsg = new_string_buffer();
#ifdef WIN32
WSADATA wsadata;
WSAStartup(MAKEWORD(2,0), &wsadata);
#endif
rc = libssh2_init (0);
if (rc != 0) {
sbprintf (sberrmsg, "libssh2 initialization failed (%d)\n", rc);
*errmsg = free_string_buffer(sberrmsg, 0);
return 1;
}
hostaddr = inet_addr(hostip);
/* Ultra basic "connect to port 22 on localhost"
* Your code is responsible for creating the socket establishing the
* connection
*/
sock = socket(AF_INET, SOCK_STREAM, 0);
sin.sin_family = AF_INET;
sin.sin_port = htons(22);
sin.sin_addr.s_addr = hostaddr;
if (connect(sock, (struct sockaddr*)(&sin),
sizeof(struct sockaddr_in)) != 0) {
sbprintf(sberrmsg, "failed to connect!\n");
*errmsg = free_string_buffer(sberrmsg, 0);
return -1;
}
/* Create a session instance */
session = libssh2_session_init();
if (!session)
return -1;
/* tell libssh2 we want it all done non-blocking */
libssh2_session_set_blocking(session, 0);
/* ... start it up. This will trade welcome banners, exchange keys,
* and setup crypto, compression, and MAC layers
*/
while ((rc = libssh2_session_handshake(session, sock)) ==
LIBSSH2_ERROR_EAGAIN);
if (rc) {
sbprintf(sberrmsg, "Failure establishing SSH session: %d\n", rc);
*errmsg = free_string_buffer(sberrmsg, 0);
return -1;
}
nh = libssh2_knownhost_init(session);
if(!nh) {
/* eeek, do cleanup here */
return 2;
}
/* We could authenticate via password */
while ((rc = libssh2_userauth_password(session, username, password)) ==
LIBSSH2_ERROR_EAGAIN);
if (rc) {
sbprintf(sberrmsg, "Authentication by password failed.\n");
*errmsg = free_string_buffer(sberrmsg, 0);
}
else {
free_string_buffer(sberrmsg, 1);
}
libssh2_session_disconnect(session,
"Normal Shutdown, Thank you for playing");
libssh2_session_free(session);
#ifdef WIN32
closesocket(sock);
#else
close(sock);
#endif
libssh2_exit();
return rc;
}
//get the next latin word from the current position.
__STATIC_API__ friso_hits_t next_basic_latin( friso_t friso, friso_task_t task ) {
char __convert = 0, t = 0;
string_buffer_t sb, temp;
lex_entry_t e = NULL;
//full-half width and upper-lower case exchange.
task->unicode = get_utf8_unicode( task->buffer );
___LATAIN_FULL_UPPER_CHECK___
//creat a new string buffer and append the task->buffer insite.
sb = new_string_buffer_with_string( task->buffer );
//segmentation.
while ( ( task->bytes = read_next_word( task, &task->idx, task->buffer ) ) != 0 ) {
task->unicode = get_utf8_unicode( task->buffer );
if ( utf8_whitespace( task->unicode ) ) break;
if ( utf8_en_punctuation( task->unicode ) && ! utf8_keep_punctuation( task->buffer ) ) break;
if ( ! ( utf8_halfwidth_letter_digit( task->unicode ) || utf8_fullwidth_letter_digit( task->unicode ) ) ) {
task->idx -= task->bytes;
t = 1;
break;
}
//full-half width and upper-lower case convert
___LATAIN_FULL_UPPER_CHECK___
//append the word the buffer.
string_buffer_append( sb, task->buffer );
}
/*clear the useless english punctuation from
the end of the buffer.*/
for ( ; sb->length > 0
&& sb->buffer[ sb->length - 1 ] != '%'
&& is_en_punctuation( sb->buffer[ sb->length - 1 ] ); ) {
sb->buffer[ --sb->length ] = '\0';
}
/*
* find the chinese or english mixed word.
* or single chinese units.*/
if ( t == 1 ) {
if ( utf8_cjk_string( task->unicode ) ) {
//temp string buffer.
temp = new_string_buffer_with_string( sb->buffer );
for ( t = 0;
t < friso->mix_len
&& ( task->bytes = read_next_word( task , &task->idx, task->buffer ) ) != 0; t++ ) {
task->unicode = get_utf8_unicode( task->buffer );
if ( ! utf8_cjk_string( task->unicode ) ) {
task->idx -= task->bytes;
break;
}
string_buffer_append( temp, task->buffer );
//check the mixed word dictionary.
if ( friso_dic_match( friso->dic, __LEX_MIX_WORDS__, temp->buffer ) ) {
__convert = 1;
//get the lexicon entry from the dictionary.
e = friso_dic_get( friso->dic, __LEX_MIX_WORDS__, temp->buffer );
}
}
//correct the segmentation offset.
task->idx -= ( temp->length - ( e == NULL ? sb->length : e->length ) );
free_string_buffer( temp );
//no match for mix word, try to find a single chinese unit.
if ( __convert == 0 ) {
//check if it is string made up with numeric
if ( utf8_numeric_string( sb->buffer )
&& ( task->bytes = read_next_word( task, &task->idx, task->buffer ) ) != 0 ) {
//check the single chinese units dictionary.
if ( friso_dic_match( friso->dic, __LEX_CJK_UNITS__, task->buffer ) ) {
string_buffer_append( sb, task->buffer );
} else {
task->idx -= task->bytes;
}
}
} //end convert condition
}
}
if ( __convert == 1 ) {
free_string_buffer( sb );
task->hits->word = e->word;
task->hits->type = __FRISO_SYS_WORDS__;
} else {
/*
* adjust the string buffer.
* here we do not trim the buffer cause its allocations will be free
* after the call of friso_next - sooner or later it will be released.
* if your memory almost run out, you should call string_buffer_trim.
* or we save the time to do the allocations and copy the buffer insite.
*/
//string_buffer_trim( sb );
task->hits->word = string_buffer_devote( sb );
task->hits->type = __FRISO_NEW_WORDS__;
}
return task->hits;
}
int ssh2_forward_port(const char *hostip,
const char *username,
const char *password,
int listenport,
const char *desthost,
int destport,
int *initialized,
int *finished,
char **errmsg)
{
int rc, sock = -1, listensock = -1, forwardsock = -1, i;
struct sockaddr_in sin;
socklen_t sinlen;
LIBSSH2_SESSION *session;
LIBSSH2_CHANNEL *channel = NULL;
const char *shost;
unsigned int sport;
fd_set fds;
struct timeval tv;
ssize_t len, wr;
char buf[16384];
struct StringBuffer *sberrmsg = new_string_buffer();
#ifdef WIN32
char sockopt;
WSADATA wsadata;
WSAStartup(MAKEWORD(2,0), &wsadata);
#else
int sockopt;
#endif
rc = libssh2_init (0);
if (rc != 0) {
sbprintf (sberrmsg, "libssh2 initialization failed (%d)\n", rc);
return 1;
}
/* Connect to SSH server */
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
if (INADDR_NONE == (sin.sin_addr.s_addr = inet_addr(hostip))) {
perror("inet_addr");
return -1;
}
sin.sin_port = htons(22);
if (connect(sock, (struct sockaddr*)(&sin),
sizeof(struct sockaddr_in)) != 0) {
sbprintf(sberrmsg, "failed to connect!\n");
return -1;
}
/* Create a session instance */
session = libssh2_session_init();
if(!session) {
sbprintf(sberrmsg, "Could not initialize SSH session!\n");
return -1;
}
/* ... start it up. This will trade welcome banners, exchange keys,
* and setup crypto, compression, and MAC layers
*/
rc = libssh2_session_handshake(session, sock);
if(rc) {
sbprintf(sberrmsg, "Error when starting up SSH session: %d\n", rc);
return -1;
}
if (libssh2_userauth_password(session, username, password)) {
sbprintf(sberrmsg, "Authentication by password failed.\n");
goto shutdown;
}
listensock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
sin.sin_family = AF_INET;
sin.sin_port = htons(listenport);
if (INADDR_NONE == (sin.sin_addr.s_addr = inet_addr("127.0.0.1"))) {
sbprintf(sberrmsg, "inet_addr: %s.", strerror(errno));
goto shutdown;
}
sockopt = 1;
setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(sockopt));
sinlen=sizeof(sin);
if (-1 == bind(listensock, (struct sockaddr *)&sin, sinlen)) {
sbprintf(sberrmsg, "bind: %s.", strerror(errno));
goto shutdown;
}
if (-1 == listen(listensock, 2)) {
sbprintf(sberrmsg, "listen: %s.", strerror(errno));
goto shutdown;
}
printf("Waiting for TCP connection on %s:%d...\n",
inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
*initialized = 1;
forwardsock = accept(listensock, (struct sockaddr *)&sin, &sinlen);
if (-1 == forwardsock) {
sbprintf(sberrmsg, "accept: %s.", strerror(errno));
goto shutdown;
}
shost = inet_ntoa(sin.sin_addr);
sport = ntohs(sin.sin_port);
printf("Forwarding connection from %s:%d here to remote %s:%d\n", shost,
sport, desthost, destport);
channel = libssh2_channel_direct_tcpip_ex(session, desthost,
destport, shost, sport);
if (!channel) {
sbprintf(sberrmsg, "Could not open the direct-tcpip channel!\n"
"(Note that this can be a problem at the server!"
" Please review the server logs.)\n");
goto shutdown;
}
/* Must use non-blocking IO hereafter due to the current libssh2 API */
libssh2_session_set_blocking(session, 0);
while (1) {
if(*finished) libssh2_channel_send_eof(channel);
FD_ZERO(&fds);
FD_SET(forwardsock, &fds);
tv.tv_sec = 0;
tv.tv_usec = 100000;
rc = select(forwardsock + 1, &fds, NULL, NULL, &tv);
if (-1 == rc) {
sbprintf(sberrmsg, "select: %s.", strerror(errno));
goto shutdown;
}
if (rc && FD_ISSET(forwardsock, &fds)) {
len = recv(forwardsock, buf, sizeof(buf), 0);
if (len < 0) {
perror("read");
goto shutdown;
} else if (0 == len) {
printf("The client at %s:%d disconnected!\n", shost, sport);
goto shutdown;
}
wr = 0;
do {
i = libssh2_channel_write(channel, buf, len);
if (i < 0) {
sbprintf(sberrmsg, "libssh2_channel_write: %d\n", i);
goto shutdown;
}
wr += i;
} while(i > 0 && wr < len);
}
while (1) {
len = libssh2_channel_read(channel, buf, sizeof(buf));
if (LIBSSH2_ERROR_EAGAIN == len)
break;
else if (len < 0) {
sbprintf(sberrmsg, "libssh2_channel_read: %d", (int)len);
goto shutdown;
}
wr = 0;
while (wr < len) {
i = send(forwardsock, buf + wr, len - wr, 0);
if (i <= 0) {
perror("write");
goto shutdown;
}
wr += i;
}
if (libssh2_channel_eof(channel)) {
printf("The server at %s:%d disconnected!\n",
desthost, destport);
goto shutdown;
}
}
}
shutdown:
fprintf(stderr, "finished = %d\n", *finished);
#ifdef WIN32
closesocket(forwardsock);
closesocket(listensock);
#else
close(forwardsock);
close(listensock);
#endif
if (channel)
libssh2_channel_free(channel);
libssh2_session_disconnect(session, "Client disconnecting normally");
libssh2_session_free(session);
#ifdef WIN32
closesocket(sock);
#else
close(sock);
#endif
libssh2_exit();
if(string_buffer_is_empty(sberrmsg)) {
free_string_buffer(sberrmsg, 1);
return 0;
}
*errmsg = free_string_buffer(sberrmsg, 0);
return 1;
}