char *GetWNStr(char *searchstr, int dbase)
{
register int i, j, k, offset = 0;
register char c;
char *underscore = NULL, *hyphen = NULL, *period = NULL;
static char strings[MAX_TRIES][WORDBUF];
ToLowerCase(searchstr);
if (!(underscore = strchr(searchstr, '_')) &&
!(hyphen = strchr(searchstr, '-')) &&
!(period = strchr(searchstr, '.')))
return (strcpy(strings[0],searchstr));
for(i = 0; i < 3; i++)
strcpy(strings[i], searchstr);
if (underscore != NULL) strsubst(strings[1], '_', '-');
if (hyphen != NULL) strsubst(strings[2], '-', '_');
for(i = j = k = 0; (c = searchstr[i]) != '\0'; i++){
if(c != '_' && c != '-') strings[3][j++] = c;
if(c != '.') strings[4][k++] = c;
}
strings[3][j] = '\0';
strings[4][k] = '\0';
for(i = 1; i < MAX_TRIES; i++)
if(strcmp(strings[0], strings[i]) == 0) strings[i][0] = '\0';
for (i = (MAX_TRIES - 1); i >= 0; i--)
if (strings[i][0] != '\0')
if (bin_search(strings[i], indexfps[dbase]) != NULL)
offset = i;
return(strings[offset]);
}
int SRM_mk_select(SRM *srmp,char *DBOWN,char *where)
{
register char *p,*p1;
char *whp=0;
if(!where) return -1;
if(*where && (toupper(*where)=='S' && toupper(where[1])=='E')) return 0; //如果是select,不作处理
if(!srmp->tp) return -1;
if(*where) {
whp=strdup(where);
if(!whp) {
return MEMERR;
}
}
p=where;
if(srmp->befor) {
p=stpcpy(p,srmp->befor);
*p++ = ' ';
srmp->befor=0;
}
p=stpcpy(p,"SELECT ");
if(srmp->hint) {
p=stpcpy(p, srmp->hint);
*p++ = ' ';
}
mkfield(p,srmp->tp,0);
p1=where;
while((p1=strcasestr((const char *)p1,(const char *)pre_tabname)) != 0) {
if(*DBOWN) p1=strsubst(p1,3,DBOWN);
else p1=strsubst(p1,4,DBOWN);
}
p+=strlen(p);
p=stpcpy(p," FROM ");
p1=stptok(srmp->tabname,0,0," ,.");
if(!*p1) { //简单表名
if(DBOWN && *DBOWN) {
p=stpcpy(p, DBOWN);
*p++='.';
*p=0;
}
p=stpcpy(p,srmp->tabname);
*p++=' ';
*p=0;
} else {
p=addown_to_name(p,DBOWN,srmp->tabname);
*p++=' ';
*p=0;
}
if(whp) {
p=addown_to_name(p,DBOWN,whp);
free(whp);
}
return 0;
}
void set_dbo(char *buf,char *DBOWN)
{
char *p;
p=buf;
while(0!=(p=strcasestr(p,pre_tabname))) {
if(*DBOWN) {
p=strsubst(p,3,DBOWN);
p++;
} else {
p=strsubst(p,4,0);
}
}
}
/*
* smb_pathname_preprocess
*
* Perform common pre-processing of pn->pn_path:
* - if the pn_path is blank, set it to '\\'
* - perform unicode wildcard converstion.
* - convert any '/' to '\\'
* - eliminate duplicate slashes
* - remove trailing slashes
* - quota directory specific pre-processing
*/
static void
smb_pathname_preprocess(smb_request_t *sr, smb_pathname_t *pn)
{
char *p;
/* treat empty path as "\\" */
if (strlen(pn->pn_path) == 0) {
pn->pn_path = smb_pathname_strdup(sr, "\\");
return;
}
if (sr->session->dialect < NT_LM_0_12)
smb_convert_wildcards(pn->pn_path);
/* treat '/' as '\\' */
(void) strsubst(pn->pn_path, '/', '\\');
(void) strcanon(pn->pn_path, "\\");
/* remove trailing '\\' */
p = pn->pn_path + strlen(pn->pn_path) - 1;
if ((p != pn->pn_path) && (*p == '\\'))
*p = '\0';
smb_pathname_preprocess_quota(sr, pn);
smb_pathname_preprocess_adminshare(sr, pn);
}
/*
* Adds an entry with given DFS name (root sharename) and relative path
* to the share (relpath) and the specified entry type (i.e. root/link)
* to the namespace cache.
*/
uint32_t
dfs_cache_add_byname(const char *name, const char *relpath, uint32_t type)
{
char uncpath[DFS_PATH_MAX];
char fspath[DFS_PATH_MAX];
smb_share_t si;
if (smb_shr_get((char *)name, &si) != NERR_Success)
return (ERROR_NOT_FOUND);
if (type == DFS_OBJECT_ROOT) {
(void) snprintf(uncpath, DFS_PATH_MAX, "\\\\%s\\%s",
dfs_nbname, name);
return (dfs_cache_add_byunc(uncpath, si.shr_path, type));
}
/* add link entry */
(void) snprintf(fspath, DFS_PATH_MAX, "%s/%s", si.shr_path, relpath);
(void) snprintf(uncpath, DFS_PATH_MAX, "\\\\%s\\%s\\%s", dfs_nbname,
name, relpath);
/* relpath may contain '/' */
(void) strsubst(uncpath, '/', '\\');
return (dfs_cache_add_byunc(uncpath, fspath, type));
}
/*
* smb_query_pathname
*
* Determine the absolute pathname of 'node' within the share.
* For some levels (e.g. ALL_INFO) the pathname should include the
* sharename for others (e.g. NAME_INFO) the pathname should be
* relative to the share.
* For example if the node represents file "test1.txt" in directory
* "dir1" on share "share1"
* - if include_share is TRUE the pathname would be: \share1\dir1\test1.txt
* - if include_share is FALSE the pathname would be: \dir1\test1.txt
*
* If node represents a named stream, construct the pathname for the
* associated unnamed stream then append the stream name.
*/
static int
smb_query_pathname(smb_tree_t *tree, smb_node_t *node, boolean_t include_share,
char *buf, size_t buflen)
{
char *sharename = tree->t_sharename;
int rc;
size_t len;
vnode_t *vp;
if (include_share) {
len = snprintf(buf, buflen, "\\%s", sharename);
if (len == (buflen - 1))
return (ENAMETOOLONG);
buf += len;
buflen -= len;
}
if (SMB_IS_STREAM(node))
vp = node->n_unode->vp;
else
vp = node->vp;
rc = vnodetopath(tree->t_snode->vp, vp, buf, buflen, kcred);
if (rc == 0) {
(void) strsubst(buf, '/', '\\');
if (SMB_IS_STREAM(node))
(void) strlcat(buf, node->od_name, buflen);
}
return (rc);
}
void sub_vars(char* str) {
#ifdef KERNEL_SUPPORT
char varname[LIMIT], varval[LIMIT];
varname[0] = '\0';
while(syscall(__NR_NextVariable, varname, varname, LIMIT, varval, LIMIT) == 0) {
strsubst(str, varname, varval);
}
#elif defined(KERNEL_DEBUG)
char varname[LIMIT], varval[LIMIT];
varname[0] = '\0';
while(sys_NextVariable(varname, varname, LIMIT, varval, LIMIT) == 0) {
strsubst(str, varname, varval);
}
#else
VARLIST *var = varlist;
while(var != NULL) {
strsubst(str, var->variable, var->value);
var = var->next;
}
#endif
}
/*
* Removes the namespace cache entry for the given link
* in the namespace ('name') with 'relpath'
*/
void
dfs_cache_remove(const char *name, const char *relpath)
{
dfs_nscnode_t dn;
(void) snprintf(dn.nsc_uncpath, sizeof (dn.nsc_uncpath),
"\\\\%s\\%s\\%s", dfs_nbname, name, relpath);
/* relpath may contain '/' */
(void) strsubst(dn.nsc_uncpath, '/', '\\');
smb_cache_remove(&dfs_nscache, &dn);
}
/*
* Lookup the given account and returns the account information
* in the passed smb_account_t structure.
*
* The lookup is performed in the following order:
* well known accounts
* local accounts
* domain accounts
*
* If it's established the given account is well know or local
* but the lookup fails for some reason, the next step(s) won't be
* performed.
*
* If the name is a domain account, it may refer to a user, group or
* alias. If it is a local account, its type should be specified
* in the sid_type parameter. In case the account type is unknown
* sid_type should be set to SidTypeUnknown.
*
* account argument could be either [domain\]name or [domain/]name.
*
* Return status:
*
* NT_STATUS_SUCCESS Account is successfully translated
* NT_STATUS_NONE_MAPPED Couldn't translate the account
*/
uint32_t
lsa_lookup_name(char *account, uint16_t type, smb_account_t *info)
{
char nambuf[SMB_USERNAME_MAXLEN];
char dombuf[SMB_PI_MAX_DOMAIN];
char *name, *domain;
uint32_t status;
char *slash;
(void) strsubst(account, '/', '\\');
(void) strcanon(account, "\\");
/* \john -> john */
account += strspn(account, "\\");
if ((slash = strchr(account, '\\')) != NULL) {
*slash = '\0';
(void) strlcpy(dombuf, account, sizeof (dombuf));
(void) strlcpy(nambuf, slash + 1, sizeof (nambuf));
*slash = '\\';
name = nambuf;
domain = dombuf;
} else {
name = account;
domain = NULL;
}
status = lsa_lookup_name_builtin(domain, name, info);
if (status == NT_STATUS_NOT_FOUND) {
status = smb_sam_lookup_name(domain, name, type, info);
if (status == NT_STATUS_SUCCESS)
return (status);
if ((domain == NULL) || (status == NT_STATUS_NOT_FOUND))
status = lsa_lookup_name_domain(account, info);
}
return ((status == NT_STATUS_SUCCESS) ? status : NT_STATUS_NONE_MAPPED);
}
/*
* Get referral information for the specified path from user space
* using a door call.
*/
static uint32_t
smb_dfs_referrals_get(smb_request_t *sr, char *dfs_path, dfs_reftype_t reftype,
dfs_referral_response_t *refrsp)
{
dfs_referral_query_t req;
int rc;
req.rq_type = reftype;
req.rq_path = dfs_path;
bzero(refrsp, sizeof (dfs_referral_response_t));
refrsp->rp_status = NT_STATUS_NOT_FOUND;
rc = smb_kdoor_upcall(sr->sr_server, SMB_DR_DFS_GET_REFERRALS,
&req, dfs_referral_query_xdr, refrsp, dfs_referral_response_xdr);
if (rc != 0 || refrsp->rp_status != ERROR_SUCCESS) {
return (NT_STATUS_NO_SUCH_DEVICE);
}
(void) strsubst(refrsp->rp_referrals.i_uncpath, '/', '\\');
return (NT_STATUS_SUCCESS);
}
/*
* GetPrinterData is used t obtain values from the registry for a
* printer or a print server. See [MS-RPRN] for value descriptions.
* The registry returns ERROR_FILE_NOT_FOUND for unknown keys.
*/
static int
spoolss_s_GetPrinterData(void *arg, ndr_xa_t *mxa)
{
static spoolss_winreg_t reg[] = {
{ "ChangeId", 0x0050acf2 },
{ "W3SvcInstalled", 0x00000000 },
{ "BeepEnabled", 0x00000000 },
{ "EventLog", 0x0000001f },
{ "NetPopup", 0x00000000 },
{ "NetPopupToComputer", 0x00000000 },
{ "MajorVersion", 0x00000003 },
{ "MinorVersion", 0x00000000 },
{ "DsPresent", 0x00000000 }
};
struct spoolss_GetPrinterData *param = arg;
char *name = (char *)param->pValueName;
char buf[MAXPATHLEN];
static uint8_t reserved_buf[4];
spoolss_winreg_t *rp;
smb_share_t si;
smb_version_t *osversion;
struct utsname sysname;
smb_wchar_t *wcs;
uint32_t value;
uint32_t status;
int wcslen;
int i;
if (name == NULL || *name == '\0') {
status = ERROR_FILE_NOT_FOUND;
goto report_error;
}
for (i = 0; i < sizeof (reg) / sizeof (reg[0]); ++i) {
param->pType = WINREG_DWORD;
param->Needed = sizeof (uint32_t);
rp = ®[i];
if (strcasecmp(name, rp->name) != 0)
continue;
if (param->Size < sizeof (uint32_t)) {
param->Size = 0;
goto need_more_data;
}
if ((param->Buf = NDR_NEW(mxa, uint32_t)) == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
goto report_error;
}
value = rp->value;
if ((strcasecmp(name, "DsPresent") == 0) &&
(smb_config_get_secmode() == SMB_SECMODE_DOMAIN))
value = 0x00000001;
bcopy(&value, param->Buf, sizeof (uint32_t));
param->Size = sizeof (uint32_t);
param->status = ERROR_SUCCESS;
return (NDR_DRC_OK);
}
if (strcasecmp(name, "OSVersion") == 0) {
param->pType = WINREG_BINARY;
param->Needed = sizeof (smb_version_t);
if (param->Size < sizeof (smb_version_t)) {
param->Size = sizeof (smb_version_t);
goto need_more_data;
}
if ((osversion = NDR_NEW(mxa, smb_version_t)) == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
goto report_error;
}
smb_config_get_version(osversion);
param->Buf = (uint8_t *)osversion;
param->status = ERROR_SUCCESS;
return (NDR_DRC_OK);
}
if (strcasecmp(name, "DNSMachineName") == 0) {
param->pType = WINREG_SZ;
buf[0] = '\0';
(void) smb_getfqhostname(buf, MAXHOSTNAMELEN);
goto encode_string;
}
if (strcasecmp(name, "DefaultSpoolDirectory") == 0) {
param->pType = WINREG_SZ;
buf[0] = '\0';
if (smb_shr_get(SMB_SHARE_PRINT, &si) != NERR_Success) {
status = ERROR_FILE_NOT_FOUND;
goto report_error;
}
(void) snprintf(buf, MAXPATHLEN, "C:/%s", si.shr_path);
(void) strcanon(buf, "/\\");
(void) strsubst(buf, '/', '\\');
goto encode_string;
}
if (strcasecmp(name, "Architecture") == 0) {
param->pType = WINREG_SZ;
if (uname(&sysname) < 0)
(void) strlcpy(buf, "Solaris", MAXPATHLEN);
else
(void) snprintf(buf, MAXPATHLEN, "%s %s",
sysname.sysname, sysname.machine);
goto encode_string;
}
status = ERROR_FILE_NOT_FOUND;
report_error:
bzero(param, sizeof (struct spoolss_GetPrinterData));
param->Buf = reserved_buf;
param->status = status;
return (NDR_DRC_OK);
encode_string:
wcslen = smb_wcequiv_strlen(buf) + sizeof (smb_wchar_t);
if (param->Size < wcslen) {
param->Needed = wcslen;
goto need_more_data;
}
if ((wcs = NDR_MALLOC(mxa, wcslen)) == NULL) {
status = ERROR_NOT_ENOUGH_MEMORY;
goto report_error;
}
(void) ndr_mbstowcs(NULL, wcs, buf, wcslen);
param->Buf = (uint8_t *)wcs;
param->Needed = wcslen;
param->status = ERROR_SUCCESS;
return (NDR_DRC_OK);
need_more_data:
param->Size = 0;
param->Buf = reserved_buf;
param->status = ERROR_MORE_DATA;
return (NDR_DRC_OK);
}
int
smb_pathname_reduce(
smb_request_t *sr,
cred_t *cred,
const char *path,
smb_node_t *share_root_node,
smb_node_t *cur_node,
smb_node_t **dir_node,
char *last_component)
{
smb_node_t *root_node;
pathname_t ppn;
char *usepath;
int lookup_flags = FOLLOW;
int trailing_slash = 0;
int err = 0;
int len;
smb_node_t *vss_cur_node;
smb_node_t *vss_root_node;
smb_node_t *local_cur_node;
smb_node_t *local_root_node;
ASSERT(dir_node);
ASSERT(last_component);
*dir_node = NULL;
*last_component = '\0';
vss_cur_node = NULL;
vss_root_node = NULL;
if (sr && sr->tid_tree) {
if (STYPE_ISIPC(sr->tid_tree->t_res_type))
return (EACCES);
}
if (SMB_TREE_IS_CASEINSENSITIVE(sr))
lookup_flags |= FIGNORECASE;
if (path == NULL)
return (EINVAL);
if (*path == '\0')
return (ENOENT);
usepath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
if ((len = strlcpy(usepath, path, MAXPATHLEN)) >= MAXPATHLEN) {
kmem_free(usepath, MAXPATHLEN);
return (ENAMETOOLONG);
}
(void) strsubst(usepath, '\\', '/');
if (share_root_node)
root_node = share_root_node;
else
root_node = sr->sr_server->si_root_smb_node;
if (cur_node == NULL)
cur_node = root_node;
local_cur_node = cur_node;
local_root_node = root_node;
if (SMB_TREE_IS_DFSROOT(sr) && (sr->smb_flg2 & SMB_FLAGS2_DFS)) {
err = smb_pathname_dfs_preprocess(sr, usepath, MAXPATHLEN);
if (err != 0) {
kmem_free(usepath, MAXPATHLEN);
return (err);
}
len = strlen(usepath);
}
if (sr && (sr->smb_flg2 & SMB_FLAGS2_REPARSE_PATH)) {
err = smb_vss_lookup_nodes(sr, root_node, cur_node,
usepath, &vss_cur_node, &vss_root_node);
if (err != 0) {
kmem_free(usepath, MAXPATHLEN);
return (err);
}
len = strlen(usepath);
local_cur_node = vss_cur_node;
local_root_node = vss_root_node;
}
if (usepath[len - 1] == '/')
trailing_slash = 1;
(void) strcanon(usepath, "/");
(void) pn_alloc(&ppn);
if ((err = pn_set(&ppn, usepath)) != 0) {
(void) pn_free(&ppn);
kmem_free(usepath, MAXPATHLEN);
if (vss_cur_node != NULL)
(void) smb_node_release(vss_cur_node);
if (vss_root_node != NULL)
(void) smb_node_release(vss_root_node);
return (err);
}
/*
* If a path does not have a trailing slash, strip off the
* last component. (We only need to return an smb_node for
* the second to last component; a name is returned for the
* last component.)
*/
if (trailing_slash) {
(void) strlcpy(last_component, ".", MAXNAMELEN);
} else {
(void) pn_setlast(&ppn);
(void) strlcpy(last_component, ppn.pn_path, MAXNAMELEN);
ppn.pn_path[0] = '\0';
}
if ((strcmp(ppn.pn_buf, "/") == 0) || (ppn.pn_buf[0] == '\0')) {
smb_node_ref(local_cur_node);
*dir_node = local_cur_node;
} else {
err = smb_pathname(sr, ppn.pn_buf, lookup_flags,
local_root_node, local_cur_node, NULL, dir_node, cred);
}
(void) pn_free(&ppn);
kmem_free(usepath, MAXPATHLEN);
/*
* Prevent traversal to another file system if mount point
* traversal is disabled.
*
* Note that we disregard whether the traversal of the path went
* outside of the file system and then came back (say via a link).
* This means that only symlinks that are expressed relatively to
* the share root work.
*
* share_root_node is NULL when mapping a share, so we disregard
* that case.
*/
if ((err == 0) && share_root_node) {
if (share_root_node->vp->v_vfsp != (*dir_node)->vp->v_vfsp) {
err = EACCES;
if ((sr) && (sr)->tid_tree &&
smb_tree_has_feature((sr)->tid_tree,
SMB_TREE_TRAVERSE_MOUNTS))
err = 0;
}
}
if (err) {
if (*dir_node) {
(void) smb_node_release(*dir_node);
*dir_node = NULL;
}
*last_component = 0;
}
if (vss_cur_node != NULL)
(void) smb_node_release(vss_cur_node);
if (vss_root_node != NULL)
(void) smb_node_release(vss_root_node);
return (err);
}
int getlist(T_Connect *conn,T_NetHead *NetHead)
{
char *buff,*env,*p;
char *p1,*p2;
char tmp[1000],dir[512],tmp1[2000];
FILE *fd;
int ret,dirnum;
char buffer[4096];
if(!NetHead->pkg_len) {
ShowLog(1,"getlist what to list?");
NetHead->errno1=0;
errret:
NetHead->data=0;
NetHead->pkg_len=0;
NetHead->errno2=-1;
NetHead->pkg_rec_num=0;
NetHead->o_node=0;
NetHead->d_node=0;
ret=SendPack(conn,NetHead);
return 0;
}
buff=malloc(NetHead->pkg_len+100);
strcpy(buff,NetHead->data);
ShowLog(5,"%s",buff);
if(!strncmp(buff,"$/",2)) {
env=getenv("SENDDIR");
p=buff+2;
} else if(!strncmp(buff,"@/",2)) {
env=getenv("HOME");
p=buff+2;
} else if(*buff=='$') {
p=stptok(buff+1,tmp,sizeof(tmp),"/");
env=getenv(tmp);
} else {
p=buff;
}
if(p>buff) {
if(!env||!*env) env=".";
sprintf(tmp,"%s/",env);
strsubst(buff,p-buff,tmp);
}
//if(!*LOGFILE) p2="/dev/null";
//else p2=LOGFILE;
p2="/dev/null";
sprintf(tmp,"ls -R %s 2>>%s ",buff,p2);
ShowLog(5,tmp);
dirnum=0;
*dir=0;
fd=popen(tmp,"r");
if(!fd) {
ShowLog(1,"%s:err=%d",tmp,errno);
free(buff);
NetHead->errno1=errno;
goto errret;
}
buffer[0]=0;
while((ret=fscanf(fd,"%s",tmp))==1) {
if(tmp[strlen(tmp)-1]==':') { // is dir
if(!*dir) {
tmp[strlen(tmp)-1]=0;
strcpy(dir,tmp);
continue;
} else {
ShowLog(5,tmp);
break; // no -R
}
}
if(*dir) {
if(dir[strlen(dir)-1]=='/')
sprintf(tmp1,"%s%s",dir,tmp);
else sprintf(tmp1,"%s/%s",dir,tmp);
} else {
strcpy(tmp1,tmp);
}
if(isrfile(tmp1)<=0) continue; //not readble reg file
/* send tmp1 to client */
ret=strlen(buffer);
if((ret+strlen(tmp1)+2) < sizeof(buffer)) {
sprintf(buffer+ret,"%s ",tmp1);
} else {
NetHead->data=buffer;
NetHead->pkg_len=strlen(NetHead->data)+1;
NetHead->errno2=0;
NetHead->pkg_rec_num=0;
NetHead->o_node=0;
NetHead->d_node=0;
ret=SendPack(conn,NetHead);
if(ret) break;
strcpy(buffer,tmp1);
strcat(buffer," ");
}
}
pclose(fd);
if(*buffer) {
NetHead->data=buffer;
NetHead->pkg_len=strlen(NetHead->data)+1;
NetHead->errno2=0;
NetHead->pkg_rec_num=0;
NetHead->o_node=0;
NetHead->d_node=0;
ret=SendPack(conn,NetHead);
*buffer=0;
}
NetHead->data=0;
NetHead->pkg_len=0;
NetHead->errno2=100;
NetHead->pkg_rec_num=0;
NetHead->o_node=0;
NetHead->d_node=0;
ret=SendPack(conn,NetHead);
free(buff);
return 0;
}
char *morphstr(char *origstr, int pos)
{
static char searchstr[WORDBUF], str[WORDBUF];
static int svcnt, svprep;
char word[WORDBUF], *tmp;
int cnt, st_idx = 0, end_idx;
int prep;
char *end_idx1, *end_idx2;
char *append;
if (pos == SATELLITE)
pos = ADJ;
/* First time through for this string */
if (origstr != NULL) {
/* Assume string hasn't had spaces substitued with '_' */
strtolower(strsubst(strcpy(str, origstr), ' ', '_'));
searchstr[0] = '\0';
cnt = cntwords(str, '_');
svprep = 0;
/* first try exception list */
if ((tmp = exc_lookup(str, pos)) && strcmp(tmp, str)) {
svcnt = 1; /* force next time to pass NULL */
return(tmp);
}
/* Then try simply morph on original string */
if (pos != VERB && (tmp = morphword(str, pos)) && strcmp(tmp, str))
return(tmp);
if (pos == VERB && cnt > 1 && (prep = hasprep(str, cnt))) {
/* assume we have a verb followed by a preposition */
svprep = prep;
return(morphprep(str));
} else {
svcnt = cnt = cntwords(str, '-');
while (origstr && --cnt) {
end_idx1 = strchr(str + st_idx, '_');
end_idx2 = strchr(str + st_idx, '-');
if (end_idx1 && end_idx2) {
if (end_idx1 < end_idx2) {
end_idx = (int)(end_idx1 - str);
append = "_";
} else {
end_idx = (int)(end_idx2 - str);
append = "-";
}
} else {
if (end_idx1) {
end_idx = (int)(end_idx1 - str);
append = "_";
} else {
end_idx = (int)(end_idx2 - str);
append = "-";
}
}
if (end_idx < 0) return(NULL); /* shouldn't do this */
strncpy(word, str + st_idx, end_idx - st_idx);
word[end_idx - st_idx] = '\0';
if(tmp = morphword(word, pos))
strcat(searchstr,tmp);
else
strcat(searchstr,word);
strcat(searchstr, append);
st_idx = end_idx + 1;
}
if(tmp = morphword(strcpy(word, str + st_idx), pos))
strcat(searchstr,tmp);
else
strcat(searchstr,word);
if(strcmp(searchstr, str) && is_defined(searchstr,pos))
return(searchstr);
else
return(NULL);
}
} else { /* subsequent call on string */
if (svprep) { /* if verb has preposition, no more morphs */
svprep = 0;
return(NULL);
} else if (svcnt == 1)
return(exc_lookup(NULL, pos));
else {
svcnt = 1;
if ((tmp = exc_lookup(str, pos)) && strcmp(tmp, str))
return(tmp);
else
return(NULL);
}
}
}
/* file_list: server */
int filels(T_Connect *conn,T_NetHead *NetHead)
{
char *buff,*env,*p;
char *p1;
char tmp[1000],dir[512],tmp1[2000];
FILE *fd;
int ret;
char buffer[SDBC_BLKSZ];
int Event_no=NetHead->PROTO_NUM;
if(!NetHead->PKG_LEN) {
ShowLog(1,"getlist what to list?");
NetHead->ERRNO1=-1;
errret:
NetHead->PROTO_NUM=PutEvent(conn,Event_no);
NetHead->data=0;
NetHead->PKG_LEN=0;
NetHead->ERRNO2=-1;
NetHead->PKG_REC_NUM=0;
NetHead->O_NODE=LocalAddr(conn->Socket,0);
NetHead->D_NODE=0;
ret=SendPack(conn,NetHead);
return 0;
}
buff=malloc(NetHead->PKG_LEN+200);
if(!buff) {
NetHead->ERRNO1=-2;
goto errret;
}
strcpy(buff,NetHead->data);
//ShowLog(5,"errno2=%d %s",NetHead->ERRNO2,buff);
if(!strncmp(buff,"$/",2)) {
env=getenv("SENDDIR");
p=buff+1;
} else if(!strncmp(buff,"@/",2)) {
env=getenv("HOME");
p=buff+1;
} else if(*buff=='$') {
p=stptok(buff+1,tmp,sizeof(tmp),"/");
env=getenv(tmp);
} else {
p=buff;
}
if(p>buff) {
if(!env||!*env) env=".";
if(env[strlen(env)-1]=='/') env[strlen(env)-1]=0;
strcpy(tmp,env);
//ShowLog(5,"%s:env=%s,buff=%s",__FUNCTION__,env,buff);
strsubst(buff,p-buff,tmp);
}
ShowLog(5,"filelist:path=%s",buff);
sprintf(tmp,"ls %s",buff);
if(isdir(buff)>0) strcpy(dir,buff);
else {
p1=strrchr(buff,'/');
if(p1) {
*p1=0;
strcpy(dir,buff);
} else strcpy(dir,".");
}
if(dir[strlen(dir)-1]=='/') dir[strlen(dir)-1]=0;
fd=popen(tmp,"r");
if(!fd) {
ShowLog(1,"%s:err=%d",tmp,errno);
free(buff);
NetHead->ERRNO1=errno;
goto errret;
}
//ShowLog(5,"tmp=%s",tmp);
p=buffer;
*p=0;
while((ret=fscanf(fd,"%s",tmp))==1) {
if(*buffer==0 && tmp[strlen(tmp)-1] == ':') {//没找到
break;
}
p1=sc_basename(tmp);
ret=sprintf(tmp1,"%s/%s",dir,p1);
if(isrfile(tmp1)<=0) continue; //not readble reg file
/* send tmp1 to client */
if((int)(buffer+sizeof(buffer)-2-p)>ret) {
p=stpcpy(p,tmp1);
} else {
//ShowLog(5,"%s",buffer);
NetHead->PROTO_NUM=0;
NetHead->data=buffer;
NetHead->PKG_LEN=strlen(NetHead->data);
NetHead->ERRNO2= PACK_CONTINUE;
NetHead->O_NODE=LocalAddr(conn->Socket,0);
NetHead->D_NODE=0;
ret=SendPack(conn,NetHead);
if(ret) break;
p=buffer;
p=stpcpy(p,tmp1);
*p++ = ' ';
*p=0;
}
}
pclose(fd);
if(*buffer) {
//ShowLog(5,"final %s",buffer);
NetHead->PROTO_NUM=0;
NetHead->data=buffer;
NetHead->PKG_LEN=strlen(NetHead->data);
NetHead->ERRNO2= PACK_CONTINUE;
NetHead->O_NODE=LocalAddr(conn->Socket,0);
ret=SendPack(conn,NetHead);
*buffer=0;
}
NetHead->PROTO_NUM=PutEvent(conn,Event_no);
NetHead->data=0;
NetHead->PKG_LEN=0;
NetHead->ERRNO2=0;
NetHead->PKG_REC_NUM=0;
NetHead->O_NODE=LocalAddr(conn->Socket,0);
NetHead->D_NODE=0;
ret=SendPack(conn,NetHead);
free(buff);
return 0;
}
int
nem_execute_event_handler(nfc_device* nfc_device, nfc_target* tag, const nem_event_t event) {
int onerr;
const char *onerrorstr;
const nfcconf_list *actionlist;
nfcconf_block **blocklist, *myblock;
const char* action;
switch (event) {
case EVENT_TAG_INSERTED:
action = "tag_insert";
if ( _tag_uid != NULL ) {
free(_tag_uid);
}
tag_get_uid(nfc_device, tag, &_tag_uid);
break;
case EVENT_TAG_REMOVED:
action = "tag_remove";
break;
default:
return -1;
break;
}
blocklist = nfcconf_find_blocks ( _nem_execute_config_context, _nem_execute_config_block, "event", action );
if ( !blocklist ) {
DBG ( "%s", "Event block list not found" );
return -1;
}
myblock = blocklist[0];
free ( blocklist );
if ( !myblock ) {
DBG ( "Event item not found: '%s'", action );
return -1;
}
onerrorstr = nfcconf_get_str ( myblock, "on_error", "ignore" );
if ( !strcmp ( onerrorstr, "ignore" ) ) onerr = ONERROR_IGNORE;
else if ( !strcmp ( onerrorstr, "return" ) ) onerr = ONERROR_RETURN;
else if ( !strcmp ( onerrorstr, "quit" ) ) onerr = ONERROR_QUIT;
else {
onerr = ONERROR_IGNORE;
DBG ( "Invalid onerror value: '%s'. Assumed 'ignore'", onerrorstr );
}
/* search actions */
actionlist = nfcconf_find_list ( myblock, "action" );
if ( !actionlist ) {
DBG ( "No action list for event '%s'", action );
return 0;
}
// DBG ( "Onerror is set to: '%s'", onerrorstr );
if ( _tag_uid == NULL ) {
ERR( "%s", "Unable to read tag UID... This should not happend !" );
switch ( onerr ) {
case ONERROR_IGNORE:
break;
case ONERROR_RETURN:
return 0;
case ONERROR_QUIT:
exit ( EXIT_FAILURE );
default:
DBG ( "%s", "Invalid onerror value" );
return -1;
}
} else {
while ( actionlist ) {
int res;
char *action_cmd_src = actionlist->data;
char *action_cmd_dest = malloc((strlen(action_cmd_src) + strlen(_tag_uid))*sizeof(char));
strsubst(action_cmd_dest, action_cmd_src, "$TAG_UID", _tag_uid);
DBG ( "Executing action: '%s'", action_cmd_dest );
/*
there are some security issues on using system() in
setuid/setgid programs. so we will use an alternate function
*/
/* res=system(action_cmd); */
res = my_system ( action_cmd_dest );
actionlist = actionlist->next;
/* evaluate return and take care on "onerror" value */
DBG ( "Action '%s' returns %d", action_cmd_dest, res );
if ( !res ) continue;
switch ( onerr ) {
case ONERROR_IGNORE:
continue;
case ONERROR_RETURN:
return 0;
case ONERROR_QUIT:
exit ( EXIT_FAILURE );
default:
DBG ( "%s", "Invalid onerror value" );
return -1;
}
}
}
return 0;
}
