int strcompare(char* str1,char* str2)
{
int len1,len2,i,flag=0;
len1=strlength(str1);
len2=strlength(str2);
if(len1!=len2)
{
flag=1;
}
else
{
for(i=0;i<len1;i++)
{
if(str1[i]!=str2[i])
{
flag=1;
break;
}
}
}
return flag;
}
char *joinpath(const char * path1, const char * path2_in) {
if ( path1 == NULL ) {
singularity_message(ERROR, "joinpath() called with NULL path1\n");
ABORT(255);
}
if ( path2_in == NULL ) {
singularity_message(ERROR, "joinpath() called with NULL path2\n");
ABORT(255);
}
const char *path2 = path2_in;
char *tmp_path1 = strdup(path1);
int path1_len = strlength(tmp_path1, 4096);
char *ret = NULL;
if ( tmp_path1[path1_len - 1] == '/' ) {
tmp_path1[path1_len - 1] = '\0';
}
if ( path2[0] == '/' ) {
path2++;
}
size_t ret_pathlen = strlength(tmp_path1, PATH_MAX) + strlength(path2, PATH_MAX) + 2;
ret = (char *) malloc(ret_pathlen);
if (snprintf(ret, ret_pathlen, "%s/%s", tmp_path1, path2) >= ret_pathlen) { // Flawfinder: ignore
singularity_message(ERROR, "Overly-long path name.\n");
ABORT(255);
}
return(ret);
}
int stringcomp(char *chaineA, char* chaineB) //Fonction qui compare les differentes chaine de caract
{
int i=0;
while (chaineA[i]!='\0'&&chaineB[i]!='\0')
{
if (chaineA[i] > chaineB[i])
{
return -1 ;
}
else if(chaineA[i]<chaineB[i])
{
return 1 ;
}
i++;
}
if(strlength(chaineA) == strlength(chaineB))
{
return 0 ;
}
else if(strlength(chaineA) < strlength(chaineB))
{
return 1;
}
else
{
return -1;
}
}
int checkRepeatExpression(char *expression)
{
Rewind();
char *first = nextToken();
char *second = nextToken();
char *third = nextToken();
char *fourth = nextToken();
char *fifth = nextToken();
if (checkREPEAT(first, strlength(first))&&
checkN(second, strlength(second))&&
checkTIMES(third, strlength(third))&&
checkCommandList(fourth, strlength(fourth))&&
checkEND(fifth, strlength(fifth)))
{
free(first);
free(second);
free(third);
free(fourth);
free(fifth);
return 1;
} else
{
free(first);
free(second);
free(third);
free(fourth);
free(fifth);
return 0;
}
return 1;
}
char *joinpath(const char * path1, const char * path2) {
char *ret;
ret = (char *) malloc(strlength(path1, 2048) + strlength(path2, 2048) + 2);
snprintf(ret, strlen(path1) + strlen(path2) + 2, "%s/%s", path1, path2); // Flawfinder: ignore
return(ret);
}
char *strjoin(char *str1, char *str2) {
char *ret;
int len = strlength(str1, 2048) + strlength(str2, 2048) + 1;
ret = (char *) malloc(len);
snprintf(ret, len, "%s%s", str1, str2); // Flawfinder: ignore
return(ret);
}
void main()
{
char a[10]="hello";
printf("%d\n",strlength(a));
char b[strlength(a)];
strcopy(b,a);
printf("%s\n",b);
}
int main() {
char *str = "string";
char *wrd = "word";
char src[] = "source";
char dest[] = "destination";
char concat[ strlength(dest) + strlength(src) ];
char empty[100];
char a[] = "abc";
char b[] = "ab";
int i = 1;
printf( "Testing strlength with string: %s\n", str );
printf( "String length: %d \n", strlength( str ) );
printf( "Testing strlength with string: %s\n", wrd );
printf( "String length: %d\n", strlength( wrd ) );
printf( "\n" );
printf( "Testing strcopy with string: %s\n", src );
printf( "Testing strcopy with string: %s\n", empty );
strcopy( empty, src );
printf("Empty string is now: %s\n", empty );
printf( "\n" );
printf( "Testing strconcat with string: %s\n", src );
printf( "Testing strconcat with string: %s\n", dest );
printf( "Appends the first: %d character(s) \n", i );
strconcatn( concat, dest, src, i );
printf( "Concatenated string: %s\n", concat );
printf( "\n" );
printf( "Testing strcomp with string: abc and ab \n" );
printf( "%d\n", strcomp( a, b ) );
printf( "Testing strcomp with string: abc and abc \n" );
printf( "%d\n", strcomp( a, a ) );
printf( "This answer is wrong! Still working on it." );
printf( "\n" );
printf( "Testing strchar with string: %s. Return place if found -1 if not found\n", src );
printf( "Looking for s \n" );
printf( "%d\n", strchar( src, 's' ) );
printf( "Looking for 1 \n" );
printf( "%d\n", strchar( src, '1' ) );
printf( "Looking for e \n" );
printf( "%d\n", strchar( src, 'e' ) );
printf( "\n" );
printf( "Testing strstring with strings %s and %s. Return 1 if found -1 if not found \n", a, b );
printf( "%d This answer is wrong! I used my strcomp (broken method for now) in this method which is why it churned out the wrong answer. \n", strstring( a, b ) );
return 0;
}
int check_mounted(char *mountpoint) {
int retval = -1;
FILE *mounts;
char *line = (char *)malloc(MAX_LINE_LEN);
char *rootfs_dir = CONTAINER_FINALDIR;
unsigned int mountpoint_len = strlength(mountpoint, PATH_MAX);
char *real_mountpoint;
singularity_message(DEBUG, "Opening /proc/mounts\n");
if ( ( mounts = fopen("/proc/mounts", "r") ) == NULL ) { // Flawfinder: ignore
singularity_message(ERROR, "Could not open /proc/mounts: %s\n", strerror(errno));
ABORT(255);
}
if ( mountpoint[mountpoint_len-1] == '/' ) {
singularity_message(DEBUG, "Removing trailing slash from string: %s\n", mountpoint);
mountpoint[mountpoint_len-1] = '\0';
}
real_mountpoint = realpath(mountpoint, NULL); // Flawfinder: ignore
if ( real_mountpoint == NULL ) {
// mountpoint doesn't exists
return(retval);
}
singularity_message(DEBUG, "Iterating through /proc/mounts\n");
while ( fgets(line, MAX_LINE_LEN, mounts) != NULL ) {
(void) strtok(strdup(line), " ");
char *mount = strtok(NULL, " ");
// Check to see if mountpoint is already mounted
if ( strcmp(joinpath(rootfs_dir, real_mountpoint), mount) == 0 ) {
singularity_message(DEBUG, "Mountpoint is already mounted: %s\n", mountpoint);
retval = 1;
break;
}
// Check to see if path is in container root
if ( strncmp(rootfs_dir, mount, strlength(rootfs_dir, 1024)) != 0 ) {
continue;
}
// Check to see if path is ot the container root
if ( strcmp(mount, rootfs_dir) == 0 ) {
continue;
}
}
fclose(mounts);
free(line);
free(real_mountpoint);
return(retval);
}
char *strjoin(char *str1, char *str2) {
char *ret;
int len = strlength(str1, 2048) + strlength(str2, 2048) + 1;
ret = (char *) malloc(len);
if (snprintf(ret, len, "%s%s", str1, str2) >= len) { // Flawfinder: ignore
singularity_message(ERROR, "Overly-long string encountered.\n");
ABORT(255);
}
return(ret);
}
int strcomp( char a[], char b[] ) {
int c = 0;
while ( a[c] != '\0' || b[c] == '\0' ) {
if ( a[c] == b[c] )
if ( c == ( strlength( a ) - 1 ) && c == ( strlength( b ) - 1 ) )
return 1;
else
return -1;
c++;
}
return -1;
}
int strcompare(char* str1, char* str2) // return 1 if strings are the same and 0 otherwise
{
int result=0;
if (strlength(str1) != strlength(str2))
return result;
while (*str1 && (result = ((*str1) == (*str2)))) {
str1++;
str2++;
}
return result;
} // end of strcompare
int findsub(char* substr, char* eldstr) {
char* peldstr = malloc(5*sizeof(char));
char* tempstr = malloc(5*sizeof(char));
peldstr = eldstr;
int lensub = strlength(substr);
int leneld = strlength(eldstr);
while (peldstr - eldstr + lensub <= leneld) {
linecpy(peldstr++, tempstr);
if (!linecmp(substr, _linecut(tempstr, lensub))) {
return peldstr - eldstr;
}
}
return 0;
}
uint8 strEql(string str1,string str2){
uint8 result = 0;
uint16 strSize = strlength(str1);
if(strSize==strlength(str2)){
uint8 i=0;
result = 1;
for(i;i<strSize;i++){
if(str1[i]!=str2[i]){
result = 0;
break;
}
}
}
return result;
}
int strstring( char a[], char b[] ) {
int i;
int j;
for (i = 0; i < strlength( a ); i++ ) {
j = 0;
char c[100];
while ( j < strlength( b ) ) {
c[j] = b[j];
j++;
}
if ( strcomp( c, b ) == 1 )
return 1;
}
return -1;
}
uint8 strEql(char* ch1,char* ch2)
{
uint8 result = 1;
uint8 size = strlength(ch1);
if(size != strlength(ch2)) result =0;
else
{
uint8 i = 0;
for(i;i<=size;i++)
{
if(ch1[i] != ch2[i]) result = 0;
}
}
return result;
}
char* concat(char* a,char* b)
{
int i=0;int j=0;
char* c=(char*)malloc(strlength(a)+strlength(b)+1);
for(;i<strlength(a);i++)
{
c[i]=a[i];
}
for(;j<strlength(b);j++)
{
c[i]=b[j];
i++;
}
return c;
}
int verifprenom(char *prenom){
int i, lprenom;
//Calcul de la longueur de la chaine
lprenom = strlength(prenom);
//Passage vers majuscule de la chaine (option)
//lowtoupcase(prenom);
//Si 1er caractère est un espace alors invalide
if((int)prenom[0] == 32 || (int)prenom[i] == 45) {
return 0;
}
//Vérification des caractères
for(i=0;i<lprenom;++i){
if(((int)prenom[i] < 65 || (int)prenom[i] > 90) && (int)prenom[i] != 32 && (int)prenom[i] != 45 ){
return 0;
}
}
return 1;
}
char* substr(char* string, size_t position, size_t length)
{
size_t string_length = strlength(string);
if(position >= string_length)
{
return NULL;
}
char* substring = calloc(string_length + 1, sizeof(char));
if(!substring)
{
return NULL;
}
int i, j;
for (i = position, j = 0; j < length; i++, j++)
{
if(i >= string_length)
{
break;
}
substring[j] = string[i];
}
substring[j] = '\0';
return substring;
}
int verifdatenaiss(char *chaine) {
int i, j, m, a, result;
if(strlength(chaine) == 10 && chaine[2] == '/' && chaine[5] == '/') { //Si longeur de chaine = 10 ET
//si les "/" sont bien places
char jour[3] = {chaine[0], chaine[1], '\0' };
char mois[3] = {chaine[3], chaine[4], '\0' }; //Division de la date en differentes
char annee[5] = {chaine[6], chaine[7], chaine[8], chaine[9], '\0' }; //variables char[] jours, mois, annees
j = nbchartoint(jour);
m = nbchartoint(mois); //Conversion en int
a = nbchartoint(annee);
if(j <= daysinmonth(m, a) && j >= 1){ //Si le jour du mois est valide (annee bisextile)
if(a >= 1905 && a <=1996) { //Si la date est posterieure au 31 décembre 1904 et
//anterieure au 1er janvier 1997
return 1; //Alors retourne 1 = valide
}
}
}
return 0; //Dans tous les autres cas, retourne 0
}
int singularity_rootfs_init(char *source) {
char *containername = basename(strdup(source));
singularity_message(DEBUG, "Checking on container source type\n");
if ( containername != NULL ) {
setenv("SINGULARITY_CONTAINER", containername, 1);
} else {
setenv("SINGULARITY_CONTAINER", "unknown", 1);
}
singularity_message(DEBUG, "Figuring out where to mount Singularity container\n");
mount_point = strdup(singularity_config_get_value(CONTAINER_DIR));
singularity_message(VERBOSE3, "Set image mount path to: %s\n", mount_point);
if ( is_file(source) == 0 ) {
int len = strlength(source, PATH_MAX);
if ( strcmp(&source[len - 5], ".sqsh") == 0 ) {
module = ROOTFS_SQUASHFS;
return(rootfs_squashfs_init(source, joinpath(mount_point, ROOTFS_SOURCE)));
} else { // Assume it is a standard Singularity image
module = ROOTFS_IMAGE;
return(rootfs_image_init(source, joinpath(mount_point, ROOTFS_SOURCE)));
}
} else if ( is_dir(source) == 0 ) {
module = ROOTFS_DIR;
return(rootfs_dir_init(source, joinpath(mount_point, ROOTFS_SOURCE)));
}
singularity_message(ERROR, "Container not found: %s\n", source);
ABORT(255);
return(-1);
}
void chomp(char *str) {
if (!str) {return;}
int len;
int i;
len = strlength(str, 4096);
// Trim leading whitespace by shifting array.
i = 0;
while ( isspace(str[i]) ) {i++;}
if (i) {
len -= i;
memmove(str, str+i, len);
str[len] = '\0';
}
// Trim trailing whitespace and redefine NULL
while ( str[len - 1] == ' ' ) {
str[len - 1] = '\0';
len--;
}
// If str starts with a new line, there is nothing here
if ( str[0] == '\n' ) {
str[0] = '\0';
}
if ( str[len - 1] == '\n' ) {
str[len - 1] = '\0';
}
}
void printexpr(TOKEN tok, int col) /* print an expression in prefix form */
{ TOKEN opnds; int nextcol, start, i;
if (PRINTEXPRDEBUG != 0)
{ printf ("printexpr: col %d\n", col);
dbugprinttok(tok);
};
if (tok->tokentype == OPERATOR)
{ printf ("(%s", opprint[tok->whichval]);
nextcol = col + 2 + opsize[tok->whichval];
opnds = tok->operands;
start = 0;
while (opnds != NULL)
{ if (start == 0)
printf(" ");
else { printf("\n");
for (i = 0; i < nextcol; i++) printf(" ");
}
printexpr(opnds, nextcol);
if ( opnds->tokentype == IDENTIFIERTOK && nextcol < 60 )
nextcol = nextcol + 1 + strlength(opnds->stringval);
else start = 1;
opnds = opnds->link;
}
printf (")");
}
else printtok(tok);
}
int s_mkpath(char *dir, mode_t mode) {
if (!dir) {
return(-1);
}
if (strlength(dir, 2) == 1 && dir[0] == '/') {
return(0);
}
if ( is_dir(dir) == 0 ) {
// Directory already exists, stop...
return(0);
}
if ( s_mkpath(dirname(strdupa(dir)), mode) < 0 ) {
// Return if priors failed
return(-1);
}
message(DEBUG, "Creating directory: %s\n", dir);
if ( mkdir(dir, mode) < 0 ) {
message(ERROR, "Could not create directory %s: %s\n", dir, strerror(errno));
return(-1);
}
return(0);
}
void strcopy(char *s1, char *s2){
int i = strlength(s2), j;
for (j = 0; j<=i; j++){
s1[j] = s2[j];
}
printf("%s\n", s1);
}
int strcompare(char *s1, char *s2) {
int n1 = strlength(s1), n2 = strlength(s2), i;
int g, c = 0;
if (n1<n2)
g = n2;
else if (n1>n2)
g = n1;
else
g = n1;
for (i = 0; i<g; i++) {
if (s1[i] == s2[i])
c++;
else
return (s1[i] - s2[i]);
}
if (c != 0)
return 0;
}
void strconcatn( char n[], char d[], char s[], int i ) {
strcopy( n, d );
int nplace = strlength( d );
int splace = 0;
while ( splace != i ) {
n[nplace] = s[splace];
nplace++;
splace++;
}
n[nplace] = '\0';
}
int main() {
char str[10];
int len = 0;
printf("╟ы╩ф╚ы╥╗╕Ў╫╓╖√┤ог║");
fgets(str, 10, stdin);
len = strlen(str);
printf("╫╓╖√┤о│д╢╚╩╟г║%d\n", len);
len = strlength(str);
printf("╫╓╖√┤о│д╢╚╩╟г║%d\n", len);
return 0;
}
int _singularity_image_mount_squashfs_check(struct image_object *image) {
char *image_name = strdup(image->name);
int len = strlength(image_name, 1024);
if ( strcmp(&image_name[len-5], ".sqsh") != 0 ) {
singularity_message(DEBUG, "Image does not appear to be of type '.sqsh': %s\n", image->path);
return(-1);
}
return(0);
}
void stringcopy(char* source, char* destination){
int i;
for(i=0; i <= strlength(source); ++i){
destination[i] = source[i];
}
}
