unsigned find_sort_syntax(const traits* pt, charT* delim)
{
//
// compare 'a' with 'A' to see how similar they are,
// should really use a-accute but we can't portably do that,
//
typedef typename traits::string_type string_type;
typedef typename traits::char_type char_type;
// Suppress incorrect warning for MSVC
(void)pt;
char_type a[2] = {'a', '\0', };
string_type sa(pt->transform(a, a+1));
if(sa == a)
{
*delim = 0;
return sort_C;
}
char_type A[2] = { 'A', '\0', };
string_type sA(pt->transform(A, A+1));
char_type c[2] = { ';', '\0', };
string_type sc(pt->transform(c, c+1));
int pos = 0;
while((pos <= static_cast<int>(sa.size())) && (pos <= static_cast<int>(sA.size())) && (sa[pos] == sA[pos])) ++pos;
--pos;
if(pos < 0)
{
*delim = 0;
return sort_unknown;
}
//
// at this point sa[pos] is either the end of a fixed width field
// or the character that acts as a delimiter:
//
charT maybe_delim = sa[pos];
if((pos != 0) && (count_chars(sa, maybe_delim) == count_chars(sA, maybe_delim)) && (count_chars(sa, maybe_delim) == count_chars(sc, maybe_delim)))
{
*delim = maybe_delim;
return sort_delim;
}
//
// OK doen't look like a delimiter, try for fixed width field:
//
if((sa.size() == sA.size()) && (sa.size() == sc.size()))
{
// note assumes that the fixed width field is less than
// (numeric_limits<charT>::max)(), should be true for all types
// I can't imagine 127 character fields...
*delim = static_cast<charT>(++pos);
return sort_fixed;
}
//
// don't know what it is:
//
*delim = 0;
return sort_unknown;
}
//
// try performing a mobile load, based on the reset data we have
bool try_reset_load_mobile(RESET_DATA *reset, void *initiator,
int initiator_type, const char *locale) {
const char *fullkey = get_fullkey_relative(resetGetArg(reset), locale);
PROTO_DATA *proto = worldGetType(gameworld, "mproto", fullkey);
// if there's no prototype, break out
if(proto == NULL || protoIsAbstract(proto))
return FALSE;
// see if we're already at our max
if(resetGetMax(reset) != 0 &&
count_chars(NULL, mobile_list, NULL, fullkey, FALSE) >= resetGetMax(reset))
return FALSE;
if(initiator_type == INITIATOR_ROOM && resetGetRoomMax(reset) != 0 &&
(count_chars(NULL, roomGetCharacters(initiator), NULL, fullkey,
FALSE) >= resetGetRoomMax(reset)))
return FALSE;
CHAR_DATA *mob = protoMobRun(proto);
if(mob == NULL)
return FALSE;
// to the room
if(initiator_type == INITIATOR_ROOM)
char_to_room(mob, initiator);
// to a seat
else if(initiator_type == INITIATOR_ON_OBJ) {
if(!objIsType(initiator, "furniture") || objGetRoom(initiator)==NULL) {
extract_mobile(mob);
return FALSE;
}
char_to_room(mob, objGetRoom(initiator));
char_to_furniture(mob, initiator);
charSetPos(mob, POS_SITTING);
}
// after an object
else if(initiator_type == INITIATOR_THEN_OBJ) {
if(objGetRoom(initiator) == NULL) {
extract_mobile(mob);
return FALSE;
}
char_to_room(mob, objGetRoom(initiator));
}
// after another mob
else if(initiator_type == INITIATOR_THEN_MOB)
char_to_room(mob, charGetRoom(initiator));
// we shouldn't get this far
else {
extract_mobile(mob);
return FALSE;
}
// now, run all of our followup stuff
resetRunOn(reset->on, mob, INITIATOR_ON_MOB, locale);
resetRunOn(reset->in, mob, INITIATOR_IN_MOB, locale);
resetRunOn(reset->then, mob, INITIATOR_THEN_MOB, locale);
return TRUE;
}
int main(void)
{
unsigned long count = count_chars(string + 14, 'o');
if (count != 3)
return count + 1;
return 0;
}
int main(void)
{
char string1[100] = { "" };
char string2[100] = { "" };
int buffer;
puts("Say something nice, please:");
fgets(string1, 100, stdin);
puts("Once more please (pref other saying):");
fgets(string2, 100, stdin);
puts("Now I'm gonna compare your 2 strings");
puts(" and search for matching characters");
for(int x = 0; x<3; x++) {
printf("\t...");
sleep(1);
}
printf("\n\n\t");
buffer = count_chars(string1, string2);
if (buffer == 0)
puts("Sorry to dissapoint, but found no matches :-(\n");
else
printf("There are %d matches !!!\n\n", buffer);
return 0;
}
static int parse_identifier(lcc_connection_t *c, const char *value,
lcc_identifier_t *ident) {
char hostname[1024];
char ident_str[1024] = "";
int n_slashes;
int status;
n_slashes = count_chars(value, '/');
if (n_slashes == 1) {
/* The user has omitted the hostname part of the identifier
* (there is only one '/' in the identifier)
* Let's add the local hostname */
if (gethostname(hostname, sizeof(hostname)) != 0) {
fprintf(stderr, "ERROR: Failed to get local hostname: %s",
strerror(errno));
return (-1);
}
hostname[sizeof(hostname) - 1] = '\0';
snprintf(ident_str, sizeof(ident_str), "%s/%s", hostname, value);
ident_str[sizeof(ident_str) - 1] = '\0';
} else {
strncpy(ident_str, value, sizeof(ident_str));
ident_str[sizeof(ident_str) - 1] = '\0';
}
status = lcc_string_to_identifier(c, ident, ident_str);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to parse identifier ``%s'': %s.\n",
ident_str, lcc_strerror(c));
return (-1);
}
return (0);
} /* parse_identifier */
CSA::TCodeEntry * CSA::node::makecodetable(uchar *text, ulong n)
{
TCodeEntry *result = new TCodeEntry[ 256 ];
count_chars( text, n, result );
std::priority_queue< node, std::vector< node >, std::greater<node> > q;
//
// First I push all the leaf nodes into the queue
//
for ( unsigned int i = 0 ; i < 256 ; i++ )
if ( result[ i ].count )
q.push(node( i, result[ i ].count ) );
//
// This loop removes the two smallest nodes from the
// queue. It creates a new internal node that has
// those two nodes as children. The new internal node
// is then inserted into the priority queue. When there
// is only one node in the priority queue, the tree
// is complete.
//
while ( q.size() > 1 ) {
node *child0 = new node( q.top() );
q.pop();
node *child1 = new node( q.top() );
q.pop();
q.push( node( child0, child1 ) );
}
//
// Now I compute and return the codetable
//
q.top().maketable(0u,0u, result);
q.pop();
return result;
}
// write out some info when there's any change in watched files
void callback(
ConstFSEventStreamRef streamRef,
void *clientCallBackInfo,
size_t numEvents,
void *eventPaths,
const FSEventStreamEventFlags eventFlags[],
const FSEventStreamEventId eventIds[])
{
pid_t pid;
int status;
for (int i=0; i<numEvents; ++i) {
const char* path = ((char **)eventPaths)[i];
int extra = count_chars(path, ' ');
if (extra) { // produce escaped spaces in the paths
char * z = malloc(strlen(path)+1+extra);
int cur = 0, zcur = 0;
while (*path) {
if (*path == ' ')
z[zcur++] = '\\';
z[zcur++] = path[cur++];
}
printf("%x %s, ", eventFlags[i], z);
} else {
printf("%x %s, ", eventFlags[i], path);
}
}
printf("\n");
fflush(stdout);
}
/*
* Returns:
* # of 'type' tokens in 'str'.
*/
static unsigned _count_tokens(const char *str, unsigned len, int type)
{
char c;
c = _token_type_to_char(type);
return count_chars(str, len, c);
}
void make_frames(int num_words){
int i=0;
printf("\nThe Transmitted Data is:\n\t");
for(;i<num_words;i++)
printf("%d%s",(count_chars(i)+1),input[i]);
printf("\n\n");
}
int main (int argc, char *argv[]) {
if (argc < 2) {
printf("Usage: %s \"Input String\"\n", argv[0]);
exit(1);
}
else {
printf("String length = %d\n", count_chars(argc, argv));
return 0;
}
}
void GLSLTextEditor::on_document_contentChanged(int position, int charsRemoved, int charsAdded)
{
if (charsAdded == 1)
{
QTextDocument* doc = document ();
QString text = doc->toPlainText();
if (text.length () <= position)
{
return;
}
if (text.at(position) == '\n')
{
unsigned openBraces = count_chars(text, "{", position) - count_chars(text, "}", position);
if (!openBraces)
{
return;
}
QString add;
for (unsigned i=0; i<openBraces; i++)
{
add.append(" ");
}
blockSignals(true);
insertPlainText(add);
blockSignals(false);
}
else if (text.at(position) == '}')
{
if (text.at(position-1) == ' ' && text.at(position-2) == ' ')
{
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::Left, QTextCursor::MoveAnchor, 1);
cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor, 2);
cursor.insertText("");
cursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, 1);
}
}
}
fflush(stdout);
}
/*
* <vg>-<lv>-<layer> or if !layer just <vg>-<lv>.
*/
char *build_dm_name(struct dm_pool *mem, const char *vgname,
const char *lvname, const char *layer)
{
size_t len = 1;
int hyphens = 1;
char *r, *out;
count_chars(vgname, &len, &hyphens, '-');
count_chars(lvname, &len, &hyphens, '-');
if (layer && *layer) {
count_chars(layer, &len, &hyphens, '-');
hyphens++;
}
len += hyphens;
if (!(r = dm_pool_alloc(mem, len))) {
log_error("build_dm_name: Allocation failed for %" PRIsize_t
" for %s %s %s.", len, vgname, lvname, layer);
return NULL;
}
out = r;
_quote_hyphens(&out, vgname);
*out++ = '-';
_quote_hyphens(&out, lvname);
if (layer && *layer) {
/* No hyphen if the layer begins with _ e.g. _mlog */
if (*layer != '_')
*out++ = '-';
_quote_hyphens(&out, layer);
}
*out = '\0';
return r;
}
YogVal
YogEncoding_conv_to_yog(YogEnv* env, YogHandle* self, const char* begin, const char* end)
{
uint_t chars_num = count_chars(env, self, begin, end);
YogVal s = YogString_of_size(env, chars_num);
uint_t i;
const char* pc = begin;
for (i = 0; i < chars_num; i++) {
YogChar c = HDL_AS(YogEncoding, self)->conv_char_to_yog(env, self, pc);
STRING_CHARS(s)[i] = c;
pc += HDL_AS(YogEncoding, self)->get_char_bytes(env, self, pc);
}
STRING_SIZE(s) = chars_num;
return s;
}
TCodeEntry *makecodetable(uchar *text, ulong n)
{
TCodeEntry *result = new TCodeEntry[ size_uchar ];
count_chars( text, n, result );
/* ulong count=0;
for (int i=0;i<256; i++) {
count += result[i].count;
if (result[i].count>0)
printf("%c,%d: %d\n",i , i,result[i].count);
}
printf("count=%d\n",count);*/
priority_queue< node, vector< node >, greater<node> > q;
//
// First I push all the leaf nodes into the queue
//
for ( ulong i = 0 ; i < size_uchar ; i++ )
if ( result[ i ].count )
q.push(node( i, result[ i ].count ) );
//
// This loop removes the two smallest nodes from the
// queue. It creates a new internal node that has
// those two nodes as children. The new internal node
// is then inserted into the priority queue. When there
// is only one node in the priority queue, the tree
// is complete.
//
while ( q.size() > 1 ) {
node *child0 = new node( q.top() );
q.pop();
node *child1 = new node( q.top() );
q.pop();
q.push( node( child0, child1 ) );
}
//
// Now I compute and return the codetable
//
//cout << "Char Symbol Code" << endl;
//q.top().traverse();
q.top().maketable(0u,0u, result);
q.top().deleteme();
q.pop();
return result;
}
int main()
{
std::vector<std::string> words;
std::string word;
std::string line;
std::getline(std::cin,line);
std::istringstream iss(line);
while(iss >> word)
{
words.push_back(word);
}
count_chars(words);
std::cout << "longest: " << longest_string(words) << '\n';
std::cout << "shortest: " << shortest_string(words) << '\n';
std::cout << "lexico_first: " << lexico_first(words) << '\n';
std::cout << "lexico_last: " << lexico_last(words) << '\n';
std::cout << "finished \n";
return 0;
}
static SEC_DESC* parse_acl_string(TALLOC_CTX *mem_ctx, const char *szACL, size_t *sd_size )
{
SEC_DESC *sd = NULL;
SEC_ACE *ace;
SEC_ACL *acl;
int num_ace;
const char *pacl;
int i;
if ( !szACL )
return NULL;
pacl = szACL;
num_ace = count_chars( pacl, ',' ) + 1;
if ( !(ace = TALLOC_ZERO_ARRAY( mem_ctx, SEC_ACE, num_ace )) )
return NULL;
for ( i=0; i<num_ace; i++ ) {
char *end_acl = strchr_m( pacl, ',' );
fstring acl_string;
strncpy( acl_string, pacl, MIN( PTR_DIFF( end_acl, pacl ), sizeof(fstring)-1) );
acl_string[MIN( PTR_DIFF( end_acl, pacl ), sizeof(fstring)-1)] = '\0';
if ( !parse_ace( &ace[i], acl_string ) )
return NULL;
pacl = end_acl;
pacl++;
}
if ( !(acl = make_sec_acl( mem_ctx, NT4_ACL_REVISION, num_ace, ace )) )
return NULL;
sd = make_sec_desc( mem_ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
NULL, NULL, NULL, acl, sd_size);
return sd;
}
int validate_opts(void)
{
size_t i;
int ret = 0;
/* classification */
if (opt_class == NULL) {
fprintf(stderr, "Error: Classification required. See --help.\n");
return ret;
}
i = strlen(opt_class);
if ((i == 0) || (i > 120)) {
fprintf(stderr, "Error: Valid size for classification "
"is 1-120 chars\n");
return ret;
}
if (!g_str_is_ascii(opt_class)) {
fprintf(stderr, "Error: Non-ascii characters detected "
"in classification - aborting\n");
return ret;
}
if (count_chars(opt_class, '/') != 2) {
fprintf(stderr, "Error: Classification needs to be in "
"most/to/least specific format, 2 \'/\' required.\n");
return ret;
}
/* Severity */
if ((severity) < 1 || (severity > 4)) {
fprintf(stderr, "Error: Valid range for severity is 1-4\n");
return ret;
}
return 1;
}
int main(int ac, char **av)
{
int i;
i = 0;
if (ac != 10 || count_chars(av) == 0)
fprintf(stderr, "%s\n", usage);
else
{
while (++i < 10)
{
if (!check_chars(av[i]))
{
fprintf(stderr, "%s\n", "sudoku need 10 row");
return (0);
}
}
if (resolve(av, 0))
display_tab(av);
else
fprintf(stderr, "%s\n", "resolve failed");
}
return (0);
}
/*
parse a binding string into a dcerpc_binding structure
*/
_PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out)
{
struct dcerpc_binding *b;
char *options;
char *p;
int i, j, comma_count;
b = talloc_zero(mem_ctx, struct dcerpc_binding);
if (!b) {
return NT_STATUS_NO_MEMORY;
}
p = strchr(s, '@');
if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
NTSTATUS status;
DATA_BLOB blob = data_blob(s, 36);
status = GUID_from_data_blob(&blob, &b->object.uuid);
if (NT_STATUS_IS_ERR(status)) {
DEBUG(0, ("Failed parsing UUID\n"));
return status;
}
s = p + 1;
} else {
ZERO_STRUCT(b->object);
}
b->object.if_version = 0;
p = strchr(s, ':');
if (p == NULL) {
b->transport = NCA_UNKNOWN;
} else {
char *type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
if (!type) {
return NT_STATUS_NO_MEMORY;
}
for (i=0;i<ARRAY_SIZE(transports);i++) {
if (strcasecmp(type, transports[i].name) == 0) {
b->transport = transports[i].transport;
break;
}
}
if (i==ARRAY_SIZE(transports)) {
DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
return NT_STATUS_INVALID_PARAMETER;
}
talloc_free(type);
s = p+1;
}
p = strchr(s, '[');
if (p) {
b->host = talloc_strndup(b, s, PTR_DIFF(p, s));
options = talloc_strdup(mem_ctx, p+1);
if (options[strlen(options)-1] != ']') {
return NT_STATUS_INVALID_PARAMETER;
}
options[strlen(options)-1] = 0;
} else {
b->host = talloc_strdup(b, s);
options = NULL;
}
if (!b->host) {
return NT_STATUS_NO_MEMORY;
}
b->target_hostname = b->host;
b->options = NULL;
b->flags = 0;
b->assoc_group_id = 0;
b->endpoint = NULL;
b->localaddress = NULL;
if (!options) {
*b_out = b;
return NT_STATUS_OK;
}
comma_count = count_chars(options, ',');
b->options = talloc_array(b, const char *, comma_count+2);
if (!b->options) {
return NT_STATUS_NO_MEMORY;
}
for (i=0; (p = strchr(options, ',')); i++) {
b->options[i] = talloc_strndup(b, options, PTR_DIFF(p, options));
if (!b->options[i]) {
return NT_STATUS_NO_MEMORY;
}
options = p+1;
}
b->options[i] = options;
b->options[i+1] = NULL;
/* some options are pre-parsed for convenience */
for (i=0;b->options[i];i++) {
for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
size_t opt_len = strlen(ncacn_options[j].name);
if (strncasecmp(ncacn_options[j].name, b->options[i], opt_len) == 0) {
int k;
char c = b->options[i][opt_len];
if (ncacn_options[j].flag == DCERPC_LOCALADDRESS && c == '=') {
b->localaddress = talloc_strdup(b, &b->options[i][opt_len+1]);
} else if (c != 0) {
continue;
}
b->flags |= ncacn_options[j].flag;
for (k=i;b->options[k];k++) {
b->options[k] = b->options[k+1];
}
i--;
break;
}
}
}
if (b->options[0]) {
/* Endpoint is first option */
b->endpoint = b->options[0];
if (strlen(b->endpoint) == 0) b->endpoint = NULL;
for (i=0;b->options[i];i++) {
b->options[i] = b->options[i+1];
}
}
if (b->options[0] == NULL)
b->options = NULL;
*b_out = b;
return NT_STATUS_OK;
}
int seven_seg_plot(char **dest, char const *msg, char seg_char,
char spe_char, seven_seg_size available,
seven_seg_size * used)
{
int msg_len;
int nb_stdchar = 0, nb_spechar = 0, nb_chars = 0, nb_spaces = 0;
int stdchar_width = 0, spechar_width = 0, space_width = 0, real_width = 0;
int line = 0, colon_line1 = 0, colon_line2 = 0, spechar_shift = 0;
int dest_pos = 0;
char *current_char;
symbol_repr_t *current_repr;
msg_len = strlen(msg);
count_chars(msg, msg_len, &nb_stdchar, &nb_spechar);
nb_chars = nb_stdchar + nb_spechar;
nb_spaces = nb_chars - 1;
if ((available.height < MIN_HEIGHT) ||
(available.width <
STDCHAR_MIN_WIDTH * nb_stdchar + nb_spechar + nb_spaces))
return ENOSPC;
if (nb_spechar || nb_stdchar) {
stdchar_width =
(STD2SPE_WIDTH_RATIO * (available.width - nb_spaces)) /
(nb_spechar + nb_stdchar * STD2SPE_WIDTH_RATIO);
spechar_width = stdchar_width / STD2SPE_WIDTH_RATIO;
}
if (!spechar_width)
spechar_width++;
if (nb_spaces)
space_width =
(available.width - nb_stdchar * stdchar_width -
nb_spechar * spechar_width) / nb_spaces;
if (!space_width)
space_width = 1;
real_width =
nb_stdchar * stdchar_width + nb_spechar * spechar_width +
nb_spaces * space_width;
/* Clear the zone */
for (line = 0; line < available.height; line++)
memset((void *) (dest[line]), CHAR_EMPTY, real_width);
spechar_shift = (spechar_width > 1) ? spechar_width / 2 - 1 : 0;
colon_line1 = (available.height - 1) * 2 / 5;
colon_line2 = (available.height - 1) * 4 / 5;
if (colon_line1 >= available.height / 2)
colon_line1--;
if (colon_line2 - colon_line1 < 2)
colon_line2++;
for (current_char = (char *) msg; current_char < msg + msg_len;
current_char++) {
switch (*current_char) {
case ':':
dest[colon_line1][dest_pos + spechar_shift] = spe_char;
dest[colon_line2][dest_pos + spechar_shift] = spe_char;
dest_pos += (space_width + spechar_width);
break;
case '.':
dest[available.height - 1][dest_pos + spechar_shift] =
spe_char;
dest_pos += (space_width + spechar_width);
break;
/* Takes the same amount of space as a : (used for blinking clocks) */
case ';':
dest_pos += (space_width + spechar_width);
break;
default:
if ((current_repr = find_repr(*current_char))) {
draw_repr(dest, current_repr->repr, dest_pos,
available.height, stdchar_width, seg_char);
dest_pos += (space_width + stdchar_width);
}
break;
}
}
if (used) {
used->height = available.height;
used->width = real_width;
}
return 0;
}
int main(int argc, char *argv[]) {
size_t buffer_size = BUFFER_SIZE_DEFAULT;
// Read arguments
FILE *infile = stdin;
int quiet = 0;
char output = 'r';
char read_opt = '\0';
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
die(USAGE);
} else if (strcmp(argv[i], "-q") == 0) {
quiet = 1;
} else if (strcmp(argv[i], "-o") == 0) {
read_opt = 'o';
} else if (strcmp(argv[i], "-B") == 0) {
read_opt = 'B';
} else if (read_opt == 'o') {
if (strcmp(argv[i], "reads") == 0) {
output = 'r';
} else if (strcmp(argv[i], "format") == 0) {
output = 'f';
} else {
die("Invalid -o output format \"%s\"", argv[i]);
}
read_opt = '\0';
} else if (read_opt == 'B') {
if (! is_int(argv[i])) {
die("Invalid buffer size: \"%s\"", argv[i]);
}
buffer_size = atoi(argv[i]);
read_opt = '\0';
} else if (infile == stdin) {
infile = fopen(argv[i], "r");
if (errno) {
die("\"%s\"", argv[i]);
}
} else {
//TODO: allow any number of input files
die("Can only process one file argument");
}
}
int get_extremes = 1;
if (quiet && output != 'f') {
get_extremes = 0;
}
/*TODO: This assumes that there will be at least as many quality scores as there are sequence
* bases. According to Dan, we can't make that assumption.
* Then what do we do to tell when the quality lines have ended?
* Ideas for disambiguating:
* 1. If len(qual) >= len(seq), it's a HEADER (If we've already seen enough
* quality values to cover the read, the QUAL lines must be over.)
* 2. If the line plus the observed quality values so far is longer than the
* read, it must be a HEADER line.
* 3. No FASTQ format uses space characters for quality scores, according to
* Wikipedia. If there's a space character in the line, say it's a HEADER line?
* But there could still conceivably be a read with truncated quality scores,
* followed by a HEADER line that contains no spaces and is short enough to not
* exceed the read length.
* Conclusion: Just check how BioPython does it:
* http://biopython.org/DIST/docs/api/Bio.SeqIO.QualityIO-pysrc.html
* Update: BioPython just throws an error if the number of bases != num of quality scores.
*/
/* Notes on format requirements:
* Empty lines are allowed, and ignored. If there's an empty line where a sequence or quality line
* is expected, it's interpreted as 0 base/quality scores.
* This means you can have zero-length reads.
* Multi-line sequences (more than 4 lines per read) are allowed.
* The number of quality scores must be >= the number of sequence bases. If there are missing
* quality scores, this will likely fail with an error, but it could possibly succeed, giving
* incorrect results.
*/
char *line = malloc(buffer_size);
Extremes extremes;
extremes.max = 0;
extremes.min = 256;
long num_reads = 0;
long seq_len = 0;
long qual_len = 0;
State state = HEADER;
// fgets() reads a line at a time.
char *result = fgets(line, buffer_size, infile);
long line_num = 0;
while (result != NULL) {
line_num++;
if (state == HEADER) {
// Allow empty lines before the header.
if (! line_is_empty(line)) {
if (line[0] != '@') {
die("Line %ld looked like a header line but does not start with \"@\".", line_num);
}
num_reads++;
seq_len = 0;
// Assume only 1 header line.
state = SEQ;
}
} else if (state == SEQ) {
if (line[0] == '+') {
qual_len = 0;
// End of sequence line comes when we see a line starting with "+".
state = PLUS;
} else {
seq_len += count_chars(line, buffer_size);
}
} else if (state == PLUS || state == QUAL) {
// If the state is PLUS, we already saw the "+" line on the last loop.
// Assume there's only 1 "+" line, and assume we're now on a quality scores line.
if (state == QUAL && line[0] == '@') {
// If we're past the "first" quality scores line and we see one that starts with a "@",
// that's very suspicious. Allow it, but raise a warning.
fprintf(stderr, "Warning: Looking for more quality scores on line %ld but it starts with "
"\"@\".\nThis might be a header line and there were fewer quality scores "
"than bases.\n", line_num);
}
state = QUAL;
if (get_extremes) {
qual_len += count_chars_and_extremes(line, buffer_size, &extremes);
} else {
qual_len += count_chars(line, buffer_size);
}
if (qual_len >= seq_len) {
// End of quality line comes once we've seen enough quality scores to match the sequence line.
state = HEADER;
if (qual_len > seq_len) {
fprintf(stderr, "Warning on line %ld: Counted more quality scores than bases.\n", line_num);
}
}
}
result = fgets(line, buffer_size, infile);
}
char format_guess = '?';
if (get_extremes) {
format_guess = guess_quality_format(extremes, num_reads);
}
if (!quiet) {
fprintf(stderr, "Quality score ascii range: %d (%c) to %d (%c)\n",
extremes.min, (char)extremes.min, extremes.max, (char)extremes.max);
switch (format_guess) {
case 'S':
fprintf(stderr, "Format: Very likely Sanger (offset 33).\n");
break;
case 'X':
fprintf(stderr, "Format: Very likely Solexa (offset 64).\n");
break;
case 's':
fprintf(stderr, "Format: Maybe Sanger? (offset 33)\n");
break;
case 'x':
fprintf(stderr, "Format: Maybe Solexa? (offset 64)\n");
break;
case '?':
fprintf(stderr, "Format: Unknown\n");
}
}
if (output == 'r') {
printf("%ld\n", num_reads);
} else if (output == 'f') {
switch (format_guess) {
case 'S':
case 's':
printf("sanger\n");
break;
case 'X':
case 'x':
printf("solexa\n");
break;
default:
printf("?\n");
}
}
fclose(infile);
return 0;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
char *pname = argv[0];
int opt;
extern FILE *dbf;
extern char *optarg;
extern int optind;
static pstring servicesf = CONFIGFILE;
pstring term_code;
BOOL got_pass = False;
char *cmd_str="";
enum client_action cli_action = CLIENT_NONE;
int nprocs = 1;
int numops = 100;
pstring logfile;
struct client_info cli_info;
out_hnd = stdout;
rpcclient_init();
#ifdef KANJI
pstrcpy(term_code, KANJI);
#else /* KANJI */
*term_code = 0;
#endif /* KANJI */
if (!lp_load(servicesf,True, False, False))
{
fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
}
codepage_initialise(lp_client_code_page());
DEBUGLEVEL = 0;
cli_info.put_total_size = 0;
cli_info.put_total_time_ms = 0;
cli_info.get_total_size = 0;
cli_info.get_total_time_ms = 0;
cli_info.dir_total = 0;
cli_info.newer_than = 0;
cli_info.archive_level = 0;
cli_info.print_mode = 1;
cli_info.translation = False;
cli_info.recurse_dir = False;
cli_info.lowercase = False;
cli_info.prompt = True;
cli_info.abort_mget = True;
cli_info.dest_ip.s_addr = 0;
cli_info.name_type = 0x20;
pstrcpy(cli_info.cur_dir , "\\");
pstrcpy(cli_info.file_sel, "");
pstrcpy(cli_info.base_dir, "");
pstrcpy(smb_cli->domain, "");
pstrcpy(smb_cli->user_name, "");
pstrcpy(cli_info.myhostname, "");
pstrcpy(cli_info.dest_host, "");
pstrcpy(cli_info.svc_type, "A:");
pstrcpy(cli_info.share, "");
pstrcpy(cli_info.service, "");
ZERO_STRUCT(cli_info.dom.level3_sid);
pstrcpy(cli_info.dom.level3_dom, "");
ZERO_STRUCT(cli_info.dom.level5_sid);
pstrcpy(cli_info.dom.level5_dom, "");
smb_cli->nt_pipe_fnum = 0xffff;
setup_logging(pname, True);
TimeInit();
charset_initialise();
if (!get_myname(global_myname))
{
fprintf(stderr, "Failed to get my hostname.\n");
}
password[0] = 0;
if (argc < 2)
{
usage(pname);
exit(1);
}
if (*argv[1] != '-')
{
pstrcpy(cli_info.service, argv[1]);
/* Convert any '/' characters in the service name to '\' characters */
string_replace( cli_info.service, '/','\\');
argc--;
argv++;
DEBUG(1,("service: %s\n", cli_info.service));
if (count_chars(cli_info.service,'\\') < 3)
{
usage(pname);
printf("\n%s: Not enough '\\' characters in service\n", cli_info.service);
exit(1);
}
/*
if (count_chars(cli_info.service,'\\') > 3)
{
usage(pname);
printf("\n%s: Too many '\\' characters in service\n", cli_info.service);
exit(1);
}
*/
if (argc > 1 && (*argv[1] != '-'))
{
got_pass = True;
pstrcpy(password,argv[1]);
memset(argv[1],'X',strlen(argv[1]));
argc--;
argv++;
}
cli_action = CLIENT_SVC;
}
while ((opt = getopt(argc, argv,"s:O:M:S:i:N:o:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
{
switch (opt)
{
case 'm':
{
/* FIXME ... max_protocol seems to be funny here */
int max_protocol = 0;
max_protocol = interpret_protocol(optarg,max_protocol);
fprintf(stderr, "max protocol not currently supported\n");
break;
}
case 'O':
{
pstrcpy(user_socket_options,optarg);
break;
}
case 'S':
{
pstrcpy(cli_info.dest_host,optarg);
strupper(cli_info.dest_host);
cli_action = CLIENT_IPC;
break;
}
case 'i':
{
pstrcpy(scope, optarg);
break;
}
case 'U':
{
char *lp;
pstrcpy(smb_cli->user_name,optarg);
if ((lp=strchr(smb_cli->user_name,'%')))
{
*lp = 0;
pstrcpy(password,lp+1);
got_pass = True;
memset(strchr(optarg,'%')+1,'X',strlen(password));
}
break;
}
case 'W':
{
pstrcpy(smb_cli->domain,optarg);
break;
}
case 'E':
{
dbf = stderr;
break;
}
case 'I':
{
cli_info.dest_ip = *interpret_addr2(optarg);
if (zero_ip(cli_info.dest_ip))
{
exit(1);
}
break;
}
case 'N':
{
nprocs = atoi(optarg);
break;
}
case 'o':
{
numops = atoi(optarg);
break;
}
case 'n':
{
fstrcpy(global_myname, optarg);
break;
}
case 'd':
{
if (*optarg == 'A')
DEBUGLEVEL = 10000;
else
DEBUGLEVEL = atoi(optarg);
break;
}
case 'l':
{
slprintf(logfile, sizeof(logfile)-1,
"%s.client",optarg);
lp_set_logfile(logfile);
break;
}
case 'c':
{
cmd_str = optarg;
got_pass = True;
break;
}
case 'h':
{
usage(pname);
exit(0);
break;
}
case 's':
{
pstrcpy(servicesf, optarg);
break;
}
case 't':
{
pstrcpy(term_code, optarg);
break;
}
default:
{
usage(pname);
exit(1);
break;
}
}
}
if (cli_action == CLIENT_NONE)
{
usage(pname);
exit(1);
}
strupper(global_myname);
fstrcpy(cli_info.myhostname, global_myname);
DEBUG(3,("%s client started (version %s)\n",timestring(False),VERSION));
if (*smb_cli->domain == 0)
{
pstrcpy(smb_cli->domain,lp_workgroup());
}
strupper(smb_cli->domain);
load_interfaces();
if (cli_action == CLIENT_IPC)
{
pstrcpy(cli_info.share, "IPC$");
pstrcpy(cli_info.svc_type, "IPC");
}
fstrcpy(cli_info.mach_acct, cli_info.myhostname);
strupper(cli_info.mach_acct);
fstrcat(cli_info.mach_acct, "$");
/* set the password cache info */
if (got_pass)
{
if (password[0] == 0)
{
pwd_set_nullpwd(&(smb_cli->pwd));
}
else
{
pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
}
}
else
{
char *pwd = getpass("Enter Password:");
safe_strcpy(password, pwd, sizeof(password));
pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
}
create_procs(nprocs, numops, &cli_info, smb_cli, run_enums_test);
if (password[0] != 0)
{
create_procs(nprocs, numops, &cli_info, smb_cli, run_ntlogin_test);
}
fflush(out_hnd);
return(0);
}
int
main(int argc, char **argv) {
#else
int
xpath_locator(int argc, char **argv) {
#endif
if (argc < 2) {
fprintf(stderr, "Need to specify an input filename.\n"
"Usage: xpath_locator file.xml xpath1 xpath2 ...\n");
exit(1);
}
char *xml_filename = argv[1];
num_xpaths = argc - 2;
xpath_finders = (XPathFinder *) mmalloc(num_xpaths * sizeof(XPathFinder));
for (int xpath_num = 0; xpath_num < num_xpaths; ++xpath_num) {
xmlChar *xpath_expr = (xmlChar *) argv[xpath_num + 2];
XPathFinder *xpath_finder = &xpath_finders[xpath_num];
xpath_finder->original = new_string(xpath_expr);
xpath_finder->current_level = 0;
xpath_finder->line_number = 0;
xpath_finder->column_number = 0;
escape_uri_slashes(xpath_expr, TRUE);
int num_segs = xpath_finder->num_segs = count_chars(xpath_expr, '/');
XPathSegFinder *seg_finders =
(XPathSegFinder *) mmalloc(num_segs * sizeof(XPathSegFinder));
xpath_finder->seg_finders = seg_finders;
/* Extract each XPath segment */
xmlChar *seg = xstrtok(xpath_expr, "/");
int seg_num = 0;
while (seg != NULL) {
XPathSegFinder *seg_finder = &seg_finders[seg_num];
seg_finder->count = 0;
escape_uri_slashes(seg, FALSE);
seg_finder->original = new_string(seg);
// Get the element local name
xmlChar *lns = starts_with(seg, (const xmlChar *) "*:") ? seg + 2 : seg;
const xmlChar *bracket = xstrchr(seg, '[');
if (!bracket)
xpath_error(xpath_num, xpath_finder, seg_num, "No bracket found");
int local_name_len = bracket - lns;
xmlChar *local_name = seg_finder->local_name =
new_string_n(lns, local_name_len);
if (starts_with(bracket + 1, (const xmlChar *) "namespace-uri()=")) {
const xmlChar *ns_start = bracket + 18;
const xmlChar *ns_end = xstrchr(ns_start, '\'');
if (!ns_end)
xpath_error(xpath_num, xpath_finder, seg_num,
"No end to the namespace URI");
seg_finder->namespace_uri = new_string_n(ns_start, ns_end - ns_start);
bracket = xstrchr(ns_end, '[');
if (!bracket)
xpath_error(xpath_num, xpath_finder, seg_num, "No position found");
}
else {
seg_finder->namespace_uri = NULL;
}
const xmlChar *pos_start = bracket + 1;
const xmlChar *pos_end = xstrchr(pos_start, ']');
if (!pos_end)
xpath_error(xpath_num, xpath_finder, seg_num, "No closing bracket found");
size_t pos_str_len = pos_end - pos_start;
char pos_str[10];
strncpy(pos_str, (const char *) pos_start, pos_str_len);
pos_str[pos_str_len] = 0;
seg_finder->position = strtol(pos_str, NULL, 10);
if (seg_finder->position <= 0)
xpath_error(xpath_num, xpath_finder, seg_num, "Bad position argument");
seg = xstrtok(NULL, "/");
seg_num++;
}
}
// Initialize default handler structure for SAX 2
xmlSAXVersion(handlers, 2);
handlers->startElementNs = my_startElementNs;
handlers->endElementNs = my_endElementNs;
parser_level = 0; // [c] parser_level is safe
int res = xmlSAXUserParseFile(handlers, NULL, xml_filename);
// Output the results
for (int xpath_num = 0; xpath_num < num_xpaths; ++xpath_num) {
XPathFinder *xpath_finder = &xpath_finders[xpath_num];
printf("%d:%d\n", xpath_finder->line_number, xpath_finder->column_number);
}
for (int xpath_num = 0; xpath_num < num_xpaths; ++xpath_num) {
XPathFinder *xpath_finder = &xpath_finders[xpath_num];
int num_segs = xpath_finder->num_segs;
XPathSegFinder *seg_finders = xpath_finder->seg_finders;
for (int seg_num = 0; seg_num < num_segs; ++seg_num) {
XPathSegFinder *seg_finder = &seg_finders[seg_num];
ffree(seg_finder->original);
ffree(seg_finder->local_name);
ffree(seg_finder->namespace_uri);
}
ffree(xpath_finder->seg_finders);
ffree(xpath_finder->original);
}
ffree(xpath_finders);
return 0;
}
/*
parse a binding string into a dcerpc_binding structure
*/
NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out)
{
struct dcerpc_binding *b;
char *options, *type;
char *p;
int i, j, comma_count;
b = talloc(mem_ctx, struct dcerpc_binding);
if (!b) {
return NT_STATUS_NO_MEMORY;
}
p = strchr(s, '@');
if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
NTSTATUS status;
status = GUID_from_string(s, &b->object.uuid);
if (NT_STATUS_IS_ERR(status)) {
DEBUG(0, ("Failed parsing UUID\n"));
return status;
}
s = p + 1;
} else {
ZERO_STRUCT(b->object);
}
b->object.if_version = 0;
p = strchr(s, ':');
if (!p) {
return NT_STATUS_INVALID_PARAMETER;
}
type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
if (!type) {
return NT_STATUS_NO_MEMORY;
}
for (i=0;i<ARRAY_SIZE(transports);i++) {
if (strcasecmp(type, transports[i].name) == 0) {
b->transport = transports[i].transport;
break;
}
}
if (i==ARRAY_SIZE(transports)) {
DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
return NT_STATUS_INVALID_PARAMETER;
}
s = p+1;
p = strchr(s, '[');
if (p) {
b->host = talloc_strndup(b, s, PTR_DIFF(p, s));
options = talloc_strdup(mem_ctx, p+1);
if (options[strlen(options)-1] != ']') {
return NT_STATUS_INVALID_PARAMETER;
}
options[strlen(options)-1] = 0;
} else {
b->host = talloc_strdup(b, s);
options = NULL;
}
if (!b->host) {
return NT_STATUS_NO_MEMORY;
}
b->target_hostname = b->host;
b->options = NULL;
b->flags = 0;
b->endpoint = NULL;
if (!options) {
*b_out = b;
return NT_STATUS_OK;
}
comma_count = count_chars(options, ',');
b->options = talloc_array(b, const char *, comma_count+2);
if (!b->options) {
return NT_STATUS_NO_MEMORY;
}
for (i=0; (p = strchr(options, ',')); i++) {
b->options[i] = talloc_strndup(b, options, PTR_DIFF(p, options));
if (!b->options[i]) {
return NT_STATUS_NO_MEMORY;
}
options = p+1;
}
b->options[i] = options;
b->options[i+1] = NULL;
/* some options are pre-parsed for convenience */
for (i=0;b->options[i];i++) {
for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
int k;
b->flags |= ncacn_options[j].flag;
for (k=i;b->options[k];k++) {
b->options[k] = b->options[k+1];
}
i--;
break;
}
}
}
if (b->options[0]) {
/* Endpoint is first option */
b->endpoint = b->options[0];
if (strlen(b->endpoint) == 0) b->endpoint = NULL;
for (i=0;b->options[i];i++) {
b->options[i] = b->options[i+1];
}
}
if (b->options[0] == NULL)
b->options = NULL;
*b_out = b;
return NT_STATUS_OK;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
fstring base_directory;
char *pname = argv[0];
int opt;
extern FILE *dbf;
extern char *optarg;
extern int optind;
pstring query_host;
BOOL nt_domain_logon = False;
static pstring servicesf = CONFIGFILE;
pstring term_code;
char *p;
#ifdef KANJI
pstrcpy(term_code, KANJI);
#else /* KANJI */
*term_code = 0;
#endif /* KANJI */
*query_host = 0;
*base_directory = 0;
DEBUGLEVEL = 2;
setup_logging(pname,True);
TimeInit();
charset_initialise();
pid = getpid();
uid = getuid();
gid = getgid();
mid = pid + 100;
myumask = umask(0);
umask(myumask);
if (getenv("USER"))
{
pstrcpy(username,getenv("USER"));
/* modification to support userid%passwd syntax in the USER var
25.Aug.97, [email protected] */
if ((p=strchr(username,'%')))
{
*p = 0;
pstrcpy(password,p+1);
got_pass = True;
memset(strchr(getenv("USER"),'%')+1,'X',strlen(password));
}
strupper(username);
}
/* modification to support PASSWD environmental var
25.Aug.97, [email protected] */
if (getenv("PASSWD"))
pstrcpy(password,getenv("PASSWD"));
if (*username == 0 && getenv("LOGNAME"))
{
pstrcpy(username,getenv("LOGNAME"));
strupper(username);
}
if (argc < 2)
{
usage(pname);
exit(1);
}
if (*argv[1] != '-')
{
pstrcpy(service, argv[1]);
/* Convert any '/' characters in the service name to '\' characters */
string_replace( service, '/','\\');
argc--;
argv++;
if (count_chars(service,'\\') < 3)
{
usage(pname);
printf("\n%s: Not enough '\\' characters in service\n",service);
exit(1);
}
if (argc > 1 && (*argv[1] != '-'))
{
got_pass = True;
pstrcpy(password,argv[1]);
memset(argv[1],'X',strlen(argv[1]));
argc--;
argv++;
}
}
while ((opt =
getopt(argc, argv,"s:B:O:M:S:i:Nn:d:Pp:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
switch (opt)
{
case 'm':
max_protocol = interpret_protocol(optarg,max_protocol);
break;
case 'O':
pstrcpy(user_socket_options,optarg);
break;
case 'S':
pstrcpy(desthost,optarg);
strupper(desthost);
nt_domain_logon = True;
break;
case 'B':
iface_set_default(NULL,optarg,NULL);
break;
case 'D':
pstrcpy(base_directory,optarg);
break;
case 'i':
pstrcpy(scope,optarg);
break;
case 'U':
{
char *lp;
pstrcpy(username,optarg);
if ((lp=strchr(username,'%')))
{
*lp = 0;
pstrcpy(password,lp+1);
got_pass = True;
memset(strchr(optarg,'%')+1,'X',strlen(password));
}
}
break;
case 'W':
pstrcpy(workgroup,optarg);
break;
case 'E':
dbf = stderr;
break;
case 'I':
{
dest_ip = *interpret_addr2(optarg);
if (zero_ip(dest_ip)) exit(1);
have_ip = True;
}
break;
case 'n':
pstrcpy(myname,optarg);
break;
case 'N':
got_pass = True;
break;
case 'd':
if (*optarg == 'A')
DEBUGLEVEL = 10000;
else
DEBUGLEVEL = atoi(optarg);
break;
case 'l':
slprintf(debugf,sizeof(debugf)-1,"%s.client",optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'c':
cmdstr = optarg;
got_pass = True;
break;
case 'h':
usage(pname);
exit(0);
break;
case 's':
pstrcpy(servicesf, optarg);
break;
case 't':
pstrcpy(term_code, optarg);
break;
default:
usage(pname);
exit(1);
}
if (!*query_host && !*service)
{
usage(pname);
exit(1);
}
DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION));
if(!get_myname(myhostname,NULL))
{
DEBUG(0,("Failed to get my hostname.\n"));
}
if (!lp_load(servicesf,True)) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
}
codepage_initialise(lp_client_code_page());
interpret_coding_system(term_code);
if (*workgroup == 0)
pstrcpy(workgroup,lp_workgroup());
load_interfaces();
get_myname((*myname)?NULL:myname,NULL);
strupper(myname);
#ifdef NTDOMAIN
if (nt_domain_logon)
{
int ret = 0;
slprintf(service,sizeof(service), "\\\\%s\\IPC$",query_host);
strupper(service);
connect_as_ipc = True;
DEBUG(5,("NT Domain Logon. Service: %s\n", service));
if (cli_open_sockets(port))
{
if (!cli_send_login(NULL,NULL,True,True,NULL)) return(1);
do_nt_login(desthost, myhostname, Client, cnum);
cli_send_logout();
close_sockets();
}
return(ret);
}
#endif
if (cli_open_sockets(port))
{
if (!process(base_directory))
{
close_sockets();
return(1);
}
close_sockets();
}
else
return(1);
return(0);
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
BOOL interactive = True;
int opt;
extern FILE *dbf;
extern char *optarg;
extern int optind;
static pstring servicesf = CONFIGFILE;
pstring term_code;
char *p;
BOOL got_pass = False;
char *cmd_str="";
mode_t myumask = 0755;
enum client_action cli_action = CLIENT_NONE;
struct client_info cli_info;
pstring password; /* local copy only, if one is entered */
out_hnd = stdout;
fstrcpy(debugf, argv[0]);
rpcclient_init();
#ifdef KANJI
pstrcpy(term_code, KANJI);
#else /* KANJI */
*term_code = 0;
#endif /* KANJI */
DEBUGLEVEL = 2;
cli_info.put_total_size = 0;
cli_info.put_total_time_ms = 0;
cli_info.get_total_size = 0;
cli_info.get_total_time_ms = 0;
cli_info.dir_total = 0;
cli_info.newer_than = 0;
cli_info.archive_level = 0;
cli_info.print_mode = 1;
cli_info.translation = False;
cli_info.recurse_dir = False;
cli_info.lowercase = False;
cli_info.prompt = True;
cli_info.abort_mget = True;
cli_info.dest_ip.s_addr = 0;
cli_info.name_type = 0x20;
pstrcpy(cli_info.cur_dir , "\\");
pstrcpy(cli_info.file_sel, "");
pstrcpy(cli_info.base_dir, "");
pstrcpy(smb_cli->domain, "");
pstrcpy(smb_cli->user_name, "");
pstrcpy(cli_info.myhostname, "");
pstrcpy(cli_info.dest_host, "");
pstrcpy(cli_info.svc_type, "A:");
pstrcpy(cli_info.share, "");
pstrcpy(cli_info.service, "");
ZERO_STRUCT(cli_info.dom.level3_sid);
ZERO_STRUCT(cli_info.dom.level5_sid);
fstrcpy(cli_info.dom.level3_dom, "");
fstrcpy(cli_info.dom.level5_dom, "");
smb_cli->nt_pipe_fnum = 0xffff;
TimeInit();
charset_initialise();
myumask = umask(0);
umask(myumask);
if (!get_myname(global_myname))
{
fprintf(stderr, "Failed to get my hostname.\n");
}
if (getenv("USER"))
{
pstrcpy(smb_cli->user_name,getenv("USER"));
/* modification to support userid%passwd syntax in the USER var
25.Aug.97, [email protected] */
if ((p=strchr(smb_cli->user_name,'%')))
{
*p = 0;
pstrcpy(password,p+1);
got_pass = True;
memset(strchr(getenv("USER"),'%')+1,'X',strlen(password));
}
strupper(smb_cli->user_name);
}
password[0] = 0;
/* modification to support PASSWD environmental var
25.Aug.97, [email protected] */
if (getenv("PASSWD"))
{
pstrcpy(password,getenv("PASSWD"));
}
if (*smb_cli->user_name == 0 && getenv("LOGNAME"))
{
pstrcpy(smb_cli->user_name,getenv("LOGNAME"));
strupper(smb_cli->user_name);
}
if (argc < 2)
{
usage(argv[0]);
exit(1);
}
if (*argv[1] != '-')
{
pstrcpy(cli_info.service, argv[1]);
/* Convert any '/' characters in the service name to '\' characters */
string_replace( cli_info.service, '/','\\');
argc--;
argv++;
fprintf(out_hnd, "service: %s\n", cli_info.service);
if (count_chars(cli_info.service,'\\') < 3)
{
usage(argv[0]);
printf("\n%s: Not enough '\\' characters in service\n", cli_info.service);
exit(1);
}
/*
if (count_chars(cli_info.service,'\\') > 3)
{
usage(pname);
printf("\n%s: Too many '\\' characters in service\n", cli_info.service);
exit(1);
}
*/
if (argc > 1 && (*argv[1] != '-'))
{
got_pass = True;
pstrcpy(password,argv[1]);
memset(argv[1],'X',strlen(argv[1]));
argc--;
argv++;
}
cli_action = CLIENT_SVC;
}
while ((opt = getopt(argc, argv,"s:O:M:S:i:N:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
{
switch (opt)
{
case 'm':
{
/* FIXME ... max_protocol seems to be funny here */
int max_protocol = 0;
max_protocol = interpret_protocol(optarg,max_protocol);
fprintf(stderr, "max protocol not currently supported\n");
break;
}
case 'O':
{
pstrcpy(user_socket_options,optarg);
break;
}
case 'S':
{
pstrcpy(cli_info.dest_host,optarg);
strupper(cli_info.dest_host);
cli_action = CLIENT_IPC;
break;
}
case 'i':
{
extern pstring global_scope;
pstrcpy(global_scope, optarg);
strupper(global_scope);
break;
}
case 'U':
{
char *lp;
pstrcpy(smb_cli->user_name,optarg);
if ((lp=strchr(smb_cli->user_name,'%')))
{
*lp = 0;
pstrcpy(password,lp+1);
got_pass = True;
memset(strchr(optarg,'%')+1,'X',strlen(password));
}
break;
}
case 'W':
{
pstrcpy(smb_cli->domain,optarg);
break;
}
case 'E':
{
dbf = stderr;
break;
}
case 'I':
{
cli_info.dest_ip = *interpret_addr2(optarg);
if (zero_ip(cli_info.dest_ip))
{
exit(1);
}
break;
}
case 'n':
{
fstrcpy(global_myname, optarg);
break;
}
case 'N':
{
got_pass = True;
break;
}
case 'd':
{
if (*optarg == 'A')
DEBUGLEVEL = 10000;
else
DEBUGLEVEL = atoi(optarg);
break;
}
case 'l':
{
slprintf(debugf, sizeof(debugf)-1,
"%s.client", optarg);
interactive = False;
break;
}
case 'c':
{
cmd_str = optarg;
got_pass = True;
break;
}
case 'h':
{
usage(argv[0]);
exit(0);
break;
}
case 's':
{
pstrcpy(servicesf, optarg);
break;
}
case 't':
{
pstrcpy(term_code, optarg);
break;
}
default:
{
usage(argv[0]);
exit(1);
break;
}
}
}
setup_logging(debugf, interactive);
if (cli_action == CLIENT_NONE)
{
usage(argv[0]);
exit(1);
}
strupper(global_myname);
fstrcpy(cli_info.myhostname, global_myname);
DEBUG(3,("%s client started (version %s)\n",timestring(False),VERSION));
if (!lp_load(servicesf,True, False, False))
{
fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
}
codepage_initialise(lp_client_code_page());
if (*smb_cli->domain == 0) pstrcpy(smb_cli->domain,lp_workgroup());
load_interfaces();
if (cli_action == CLIENT_IPC)
{
pstrcpy(cli_info.share, "IPC$");
pstrcpy(cli_info.svc_type, "IPC");
}
fstrcpy(cli_info.mach_acct, cli_info.myhostname);
strupper(cli_info.mach_acct);
fstrcat(cli_info.mach_acct, "$");
/* set the password cache info */
if (got_pass)
{
if (password[0] == 0)
{
pwd_set_nullpwd(&(smb_cli->pwd));
}
else
{
pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
}
}
else
{
pwd_read(&(smb_cli->pwd), "Enter Password:"******"rpcclient_connect: smb_cli->fd:%d\n", smb_cli->fd));
if (smb_cli->fd <= 0)
{
fprintf(stderr, "warning: connection could not be established to %s<%02x>\n",
cli_info.dest_host, cli_info.name_type);
fprintf(stderr, "this version of smbclient may crash if you proceed\n");
exit(-1);
}
switch (cli_action)
{
case CLIENT_IPC:
{
process(&cli_info, cmd_str);
break;
}
default:
{
fprintf(stderr, "unknown client action requested\n");
break;
}
}
rpcclient_stop();
return(0);
}
static WINBINDD_GR* string2group( char *string )
{
static WINBINDD_GR grp;
char *p, *str;
char *fields[NUM_GRP_FIELDS];
int i;
char **gr_members = NULL;
int num_gr_members = 0;
if ( !string )
return NULL;
ZERO_STRUCTP( &grp );
DEBUG(10,("string2group: converting \"%s\"\n", string));
ZERO_STRUCT( fields );
for ( i=0, str=string; i<NUM_GRP_FIELDS-1; i++ ) {
if ( !(p = strchr( str, ':' )) ) {
DEBUG(0,("string2group: parsing failure\n"));
return NULL;
}
*p = '\0';
if ( str )
fields[i] = str;
str = p + 1;
}
/* group members */
if ( *str ) {
/* we already know we have a non-empty string */
num_gr_members = count_chars(str, ',') + 1;
/* if there was at least one comma, then there
are n+1 members */
if ( num_gr_members ) {
fstring buffer;
gr_members = SMB_XMALLOC_ARRAY(char*, num_gr_members+1);
i = 0;
while ( next_token(&str, buffer, ",", sizeof(buffer)) && i<num_gr_members ) {
gr_members[i++] = smb_xstrdup(buffer);
}
gr_members[i] = NULL;
}
}
/* copy fields */
fstrcpy( grp.gr_name, fields[0] );
fstrcpy( grp.gr_passwd, fields[1] );
grp.gr_gid = atoi( fields[2] );
grp.num_gr_mem = num_gr_members;
grp.gr_mem = gr_members;
/* last minute sanity checks */
if ( grp.gr_gid == 0 ) {
DEBUG(0,("string2group: Failure! gid==%lu\n", (unsigned long)grp.gr_gid));
SAFE_FREE( gr_members );
return NULL;
}
DEBUG(10,("string2group: Success\n"));
return &grp;
}
BOOL parse_usershare_acl(TALLOC_CTX *ctx, const char *acl_str, SEC_DESC **ppsd)
{
size_t s_size = 0;
const char *pacl = acl_str;
int num_aces = 0;
SEC_ACE *ace_list = NULL;
SEC_ACL *psa = NULL;
SEC_DESC *psd = NULL;
size_t sd_size = 0;
int i;
*ppsd = NULL;
/* If the acl string is blank return "Everyone:R" */
if (!*acl_str) {
SEC_DESC *default_psd = get_share_security_default(ctx, &s_size, GENERIC_READ_ACCESS);
if (!default_psd) {
return False;
}
*ppsd = default_psd;
return True;
}
num_aces = 1;
/* Add the number of ',' characters to get the number of aces. */
num_aces += count_chars(pacl,',');
ace_list = TALLOC_ARRAY(ctx, SEC_ACE, num_aces);
if (!ace_list) {
return False;
}
for (i = 0; i < num_aces; i++) {
SEC_ACCESS sa;
uint32 g_access;
uint32 s_access;
DOM_SID sid;
fstring sidstr;
uint8 type = SEC_ACE_TYPE_ACCESS_ALLOWED;
if (!next_token(&pacl, sidstr, ":", sizeof(sidstr))) {
DEBUG(0,("parse_usershare_acl: malformed usershare acl looking "
"for ':' in string '%s'\n", pacl));
return False;
}
if (!string_to_sid(&sid, sidstr)) {
DEBUG(0,("parse_usershare_acl: failed to convert %s to sid.\n",
sidstr ));
return False;
}
switch (*pacl) {
case 'F': /* Full Control, ie. R+W */
case 'f': /* Full Control, ie. R+W */
s_access = g_access = GENERIC_ALL_ACCESS;
break;
case 'R': /* Read only. */
case 'r': /* Read only. */
s_access = g_access = GENERIC_READ_ACCESS;
break;
case 'D': /* Deny all to this SID. */
case 'd': /* Deny all to this SID. */
type = SEC_ACE_TYPE_ACCESS_DENIED;
s_access = g_access = GENERIC_ALL_ACCESS;
break;
default:
DEBUG(0,("parse_usershare_acl: unknown acl type at %s.\n",
pacl ));
return False;
}
pacl++;
if (*pacl && *pacl != ',') {
DEBUG(0,("parse_usershare_acl: bad acl string at %s.\n",
pacl ));
return False;
}
pacl++; /* Go past any ',' */
se_map_generic(&s_access, &file_generic_mapping);
init_sec_access(&sa, g_access | s_access );
init_sec_ace(&ace_list[i], &sid, type, sa, 0);
}
if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, num_aces, ace_list)) != NULL) {
psd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, psa, &sd_size);
}
if (!psd) {
DEBUG(0,("parse_usershare_acl: Failed to make SEC_DESC.\n"));
return False;
}
*ppsd = psd;
return True;
}
catList *newCat(catList *head, char letter, char*v[]) {
int i, j, max, count;
catList *root, *curr, *maxNode;
root = head;
curr = root;
char *tempVector[head->wordsNum], tempAgent[atoi(v[1])], **adress = NULL;
/*Temporary vector with pointers to words of dictionary list */
for(i=0; i<head->wordsNum; i++) {
tempVector[i] = head->vector[i];
}
/* If only 2 words remaining and user is one letter to go, we are looking to cheat */
if ( (head->wordsNum == 2) && (count_chars(curr->agent, '_' ) == 1) ) {
count = 0;
for(i=0; i<2; i++) {
if(strchr(tempVector[i], letter) == NULL) {
count = count + 1;
}
}
/* Return the current node if no word has the letter */
if (count == 2) {
return curr;
}
/* Creating final node */
curr->nxt = malloc(sizeof(catList));
if (curr->nxt == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->nxt->prv = curr;
curr = curr->nxt;
curr->wordsNum = 1;
curr->vector = (char**)malloc(sizeof(char *));
if (curr->vector == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->agent = (char*)malloc((sizeof(char))*atoi(v[1])+1);
if (curr->agent == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
/* From the 2 remaining words, store the one that doesn't have the letter
in the missing position */
for(i=0; i<2; i++) {
if(strchr(tempVector[i], letter) == NULL) {
curr->vector[0] = tempVector[i];
strcpy(curr->agent, head->agent);
}
}
curr->nxt = NULL;
return curr;
}
/* Creating the node with the words that don't have the letter user gave */
curr->nxt = malloc(sizeof(catList));
if (curr->nxt == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
root = curr->nxt;
curr->nxt->prv = curr;
curr = curr->nxt;
curr->wordsNum = 0;
curr->vector = NULL;
curr->agent = malloc((sizeof(char))*atoi(v[1])+1);
if (curr->agent == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
/* Representative is still the initial, since no word here has the letter user gave */
strcpy(curr->agent, head->agent);
count = 0;
for(i=0; i<head->wordsNum; i++) {
/*Storing the pointers to words that dont have the letter, in the dynamic array */
if(strchr(tempVector[i], letter) == NULL) {
count = count +1;
curr->wordsNum = count;
curr->vector = (char **)realloc(adress, curr->wordsNum*sizeof(char *));
if (curr->vector == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->vector[count-1] = tempVector[i];
adress = curr->vector;
}
}
/* Running the temporary vector */
for(i=0; i<head->wordsNum; i++) {
/* We are looking for words that HAVE the letter */
if ( (tempVector[i] != NULL) && (strchr(tempVector[i], letter) != NULL) ) {
/* For the first word that has the letter we create new category */
curr->nxt = malloc(sizeof(catList));
if (curr->nxt == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->nxt->prv = curr;
curr = curr->nxt;
curr->agent = malloc((sizeof(char))*atoi(v[1])+1);
if (curr->agent == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
/* Representative is the initial representative with 'letter' in same position(s) as word */
strcpy(curr->agent, head->agent);
copyChar(curr->agent, tempVector[i], letter);
curr->vector = (char **)malloc(sizeof(char *));
if (curr->vector == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->vector[0] = tempVector[i];
curr->wordsNum = 1;
/* We fill that category with all words below,
that have the letter in the exact same position(s) */
for(j=i+1; j<head->wordsNum; j++) {
if(tempVector[j] != NULL) {
strcpy(tempAgent, head->agent);
copyChar(tempAgent, tempVector[j], letter);
if(strcmp(curr->agent, tempAgent) == 0) {
curr->wordsNum = curr->wordsNum + 1;
curr->vector = realloc(curr->vector, curr->wordsNum*sizeof(char *));
if (curr->vector == NULL) {
printf("ERROR: Memory allocation error in newCat\n");
exit(1);
}
curr->vector[curr->wordsNum-1] = tempVector[j];
/* Mark as NULL the pointers to words already categorized so we dont use them again */
tempVector[j] = NULL;
}
}
}
}
}
curr->nxt = NULL;
/* Running the category list from the second node and so, to find the most crowded one */
curr = root;
max = curr->wordsNum;
while(curr != NULL) {
if(curr->wordsNum>max) {max = curr->wordsNum;}
curr = curr->nxt;
}
/* Function will return the last node that has "max" words */
curr = root;
while(curr != NULL) {
if(curr->wordsNum == max) {maxNode = curr;}
curr = curr->nxt;
}
return maxNode;
}
int main(void) {
char string[] = "helloalb";
char chars[] = "loab";
int x = count_chars(string, chars);
printf("%d", x);
}
