C++ c_strdup函数代码示例

void
http_url_set_password(struct http_url *url, const char *string) {
    c_free(url->password);
    url->password = NULL;

    if (string)
        url->password = c_strdup(string);
}

void
http_url_set_user(struct http_url *url, const char *string) {
    c_free(url->user);
    url->user = NULL;

    if (string)
        url->user = c_strdup(string);
}

void
http_url_set_scheme(struct http_url *url, const char *string) {
    c_free(url->scheme);
    url->scheme = NULL;

    if (string)
        url->scheme = c_strdup(string);
}

struct http_url *
http_url_clone(const struct http_url *url) {
    struct http_url *new_url;

    new_url = http_url_new();

    if (url->scheme)
        new_url->scheme = c_strdup(url->scheme);
    if (url->user)
        new_url->user = c_strdup(url->user);
    if (url->password)
        new_url->password = c_strdup(url->password);
    if (url->host)
        new_url->host = c_strdup(url->host);
    if (url->port)
        new_url->port = c_strdup(url->port);
    new_url->port_number = url->port_number;
    if (url->path)
        new_url->path = c_strdup(url->path);
    if (url->query)
        new_url->query = c_strdup(url->query);
    if (url->fragment)
        new_url->fragment = c_strdup(url->fragment);

    if (url->query_parameters) {
        struct c_vector *parameters;

        parameters = c_vector_new(sizeof(struct http_query_parameter));
        for (size_t i = 0; i < c_vector_length(url->query_parameters); i++) {
            struct http_query_parameter *parameter;
            struct http_query_parameter new_parameter;

            parameter = c_vector_entry(url->query_parameters, i);

            http_query_parameter_init(&new_parameter);
            new_parameter.name = c_strdup(parameter->name);
            new_parameter.value = c_strdup(parameter->value);

            c_vector_append(parameters, &new_parameter);
        }

        new_url->query_parameters = parameters;
    }

    return new_url;
}

static void setup_toplevel_dir( void **state ) {
    char basepath[255];

    strcpy( basepath, "tXXXXXX");
    assert_int_equal( c_tmpname(basepath), 0 );
    printf("Using top testing dir %s\n", basepath);
    assert_int_equal( test_mkdir( basepath ), 0 );
    *state = (void*) c_strdup(basepath);
}

static void fill_stat_cache( csync_vio_file_stat_t *lfs ) {

    if( _stat_cache.name ) SAFE_FREE(_stat_cache.name);
    if( _stat_cache.etag  ) SAFE_FREE(_stat_cache.etag );

    if( !lfs) return;

    _stat_cache.name   = c_strdup(lfs->name);
    _stat_cache.mtime  = lfs->mtime;
    _stat_cache.fields = lfs->fields;
    _stat_cache.type   = lfs->type;
    _stat_cache.size   = lfs->size;
    csync_vio_file_stat_set_file_id(&_stat_cache, lfs->file_id);

    if( lfs->etag ) {
        _stat_cache.etag    = c_strdup(lfs->etag);
    }
}

csync_vio_file_stat_t* csync_vio_file_stat_copy(csync_vio_file_stat_t *file_stat) {
    csync_vio_file_stat_t *file_stat_cpy = csync_vio_file_stat_new();
    memcpy(file_stat_cpy, file_stat, sizeof(csync_vio_file_stat_t));
    if (file_stat_cpy->fields & CSYNC_VIO_FILE_STAT_FIELDS_ETAG) {
        file_stat_cpy->etag = c_strdup(file_stat_cpy->etag);
    }
    if (file_stat_cpy->directDownloadCookies) {
        file_stat_cpy->directDownloadCookies = c_strdup(file_stat_cpy->directDownloadCookies);
    }
    if (file_stat_cpy->directDownloadUrl) {
        file_stat_cpy->directDownloadUrl = c_strdup(file_stat_cpy->directDownloadUrl);
    }
    if (file_stat_cpy->checksumHeader) {
        file_stat_cpy->checksumHeader = c_strdup(file_stat_cpy->checksumHeader);
    }
    file_stat_cpy->name = c_strdup(file_stat_cpy->name);
    return file_stat_cpy;
}

END_TEST

START_TEST (check_c_strdup_nomem)
{
  const char *str = "test";
  char *tdup = NULL;

  tdup = c_strdup(str);
  fail_unless(tdup == NULL, NULL);
}

/* caller must free the memory */
csync_file_stat_t *csync_statedb_get_stat_by_inode(sqlite3 *db,
                                                   uint64_t inode) {
  csync_file_stat_t *st = NULL;
  c_strlist_t *result = NULL;
  char *stmt = NULL;
  size_t len = 0;

  if (!inode) {
      return NULL;
  }

  stmt = sqlite3_mprintf("SELECT * FROM metadata WHERE inode='%lld'",
             (long long signed int) inode);
  if (stmt == NULL) {
    return NULL;
  }

  result = csync_statedb_query(db, stmt);
  sqlite3_free(stmt);
  if (result == NULL) {
    return NULL;
  }

  if (result->count <= 6) {
    c_strlist_destroy(result);
    return NULL;
  }

  /* phash, pathlen, path, inode, uid, gid, mode, modtime */
  len = strlen(result->vector[2]);
  st = c_malloc(sizeof(csync_file_stat_t) + len + 1);
  if (st == NULL) {
    c_strlist_destroy(result);
    return NULL;
  }
  /* clear the whole structure */
  ZERO_STRUCTP(st);

  st->phash = atoll(result->vector[0]);
  st->pathlen = atoi(result->vector[1]);
  memcpy(st->path, (len ? result->vector[2] : ""), len + 1);
  st->inode = atoll(result->vector[3]);
  st->uid = atoi(result->vector[4]);
  st->gid = atoi(result->vector[5]);
  st->mode = atoi(result->vector[6]);
  st->modtime = strtoul(result->vector[7], NULL, 10);
  st->type = atoi(result->vector[8]);
  if( result->vector[9] )
    st->etag = c_strdup(result->vector[9]);
  csync_vio_set_file_id( st->file_id, result->vector[10]);

  c_strlist_destroy(result);

  return st;
}

END_TEST

START_TEST (check_c_strreplace)
{
  char *str = c_strdup("/home/%(USER)");

  str = c_strreplace(str, "%(USER)", "csync");
  fail_unless(strcmp(str, "/home/csync") == 0, NULL);

  SAFE_FREE(str);
}

// This funciton parses a line from the metadata table into the given csync_file_stat
// structure which it is also allocating.
// Note that this function calls laso sqlite3_step to actually get the info from db and
// returns the sqlite return type.
static int _csync_file_stat_from_metadata_table( csync_file_stat_t **st, sqlite3_stmt *stmt )
{
    int rc = SQLITE_ERROR;
    int column_count;
    int len;

    if( ! stmt ) {
       CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Fatal: Statement is NULL.");
       return SQLITE_ERROR;
    }

    column_count = sqlite3_column_count(stmt);

    rc = sqlite3_step(stmt);

    if( rc == SQLITE_ROW ) {
        if(column_count > 7) {
            const char *name;

            /* phash, pathlen, path, inode, uid, gid, mode, modtime */
            len = sqlite3_column_int(stmt, 1);
            *st = c_malloc(sizeof(csync_file_stat_t) + len + 1);
            if (*st == NULL) {
                return SQLITE_NOMEM;
            }
            /* clear the whole structure */
            ZERO_STRUCTP(*st);

            /* The query suceeded so use the phash we pass to the function. */
            (*st)->phash = sqlite3_column_int64(stmt, 0);

            (*st)->pathlen = sqlite3_column_int(stmt, 1);
            name = (const char*) sqlite3_column_text(stmt, 2);
            memcpy((*st)->path, (len ? name : ""), len + 1);
            (*st)->inode = sqlite3_column_int64(stmt,3);
            (*st)->uid = sqlite3_column_int(stmt, 4);
            (*st)->gid = sqlite3_column_int(stmt, 5);
            (*st)->mode = sqlite3_column_int(stmt, 6);
            (*st)->modtime = strtoul((char*)sqlite3_column_text(stmt, 7), NULL, 10);

            if(*st && column_count > 8 ) {
                (*st)->type = sqlite3_column_int(stmt, 8);
            }

            if(column_count > 9 && sqlite3_column_text(stmt, 9)) {
                (*st)->etag = c_strdup( (char*) sqlite3_column_text(stmt, 9) );
            }
            if(column_count > 10 && sqlite3_column_text(stmt,10)) {
                csync_vio_set_file_id((*st)->file_id, (char*) sqlite3_column_text(stmt, 10));
            }
        }
    }
    return rc;
}

/*
 * helper: convert a resource struct to file_stat struct.
 */
void resourceToFileStat(csync_vio_file_stat_t *lfs, struct resource *res )
{
    ZERO_STRUCTP(lfs);

    lfs->name = c_strdup( res->name );

    lfs->fields = CSYNC_VIO_FILE_STAT_FIELDS_NONE;
    if( res->type == resr_normal ) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_TYPE;
        lfs->type = CSYNC_VIO_FILE_TYPE_REGULAR;
    } else if( res->type == resr_collection ) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_TYPE;
        lfs->type = CSYNC_VIO_FILE_TYPE_DIRECTORY;
    } else {
        DEBUG_WEBDAV("ERROR: Unknown resource type %d", res->type);
    }

    // FIXME Those are defaults, we'll have to use the real ownCloud WebDAV permissions soon
    lfs->mode   = _stat_perms( lfs->type );
    lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_PERMISSIONS;

    lfs->mtime = res->modtime;
    lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_MTIME;
    lfs->size  = res->size;
    lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_SIZE;
    if( res->md5 ) {
        lfs->etag   = c_strdup(res->md5);
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_ETAG;
    }

    csync_vio_file_stat_set_file_id(lfs, res->file_id);

    if (res->directDownloadUrl) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_DIRECTDOWNLOADURL;
        lfs->directDownloadUrl = c_strdup(res->directDownloadUrl);
    }
    if (res->directDownloadCookies) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_DIRECTDOWNLOADCOOKIES;
        lfs->directDownloadCookies = c_strdup(res->directDownloadCookies);
    }
}

/*
 * helper: convert a resource struct to file_stat struct.
 */
void resourceToFileStat(csync_vio_file_stat_t *lfs, struct resource *res )
{
    ZERO_STRUCTP(lfs);

    lfs->name = c_strdup( res->name );

    lfs->fields = CSYNC_VIO_FILE_STAT_FIELDS_NONE;
    if( res->type == resr_normal ) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_TYPE;
        lfs->type = CSYNC_VIO_FILE_TYPE_REGULAR;
    } else if( res->type == resr_collection ) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_TYPE;
        lfs->type = CSYNC_VIO_FILE_TYPE_DIRECTORY;
    } else {
        DEBUG_WEBDAV("ERROR: Unknown resource type %d", res->type);
    }

    lfs->mtime = res->modtime;
    lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_MTIME;
    lfs->size  = res->size;
    lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_SIZE;
    if( res->md5 ) {
        lfs->etag   = c_strdup(res->md5);
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_ETAG;
    }

    csync_vio_file_stat_set_file_id(lfs, res->file_id);

    if (res->directDownloadUrl) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_DIRECTDOWNLOADURL;
        lfs->directDownloadUrl = c_strdup(res->directDownloadUrl);
    }
    if (res->directDownloadCookies) {
        lfs->fields |= CSYNC_VIO_FILE_STAT_FIELDS_DIRECTDOWNLOADCOOKIES;
        lfs->directDownloadCookies = c_strdup(res->directDownloadCookies);
    }
    if (strlen(res->remotePerm) > 0) {
        lfs->fields = CSYNC_VIO_FILE_STAT_FIELDS_PERM;
        strncpy(lfs->remotePerm, res->remotePerm, sizeof(lfs->remotePerm));
    }
}

static void check_c_strdup(void **state)
{
  const char *str = "test";
  char *tdup = NULL;

  (void) state; /* unused */

  tdup = c_strdup(str);
  assert_string_equal(tdup, str);

  free(tdup);
}

/*
 * dirname - parse directory component.
 */
char *c_dirname (const char *path) {
  char *newbuf = NULL;
  unsigned int len;

  if (path == NULL || *path == '\0') {
    return c_strdup(".");
  }

  len = strlen(path);

  /* Remove trailing slashes */
  while(len > 0 && path[len - 1] == '/') --len;

  /* We have only slashes */
  if (len == 0) {
    return c_strdup("/");
  }

  /* goto next slash */
  while(len > 0 && path[len - 1] != '/') --len;

  if (len == 0) {
    return c_strdup(".");
  } else if (len == 1) {
    return c_strdup("/");
  }

  /* Remove slashes again */
  while(len > 0 && path[len - 1] == '/') --len;

  newbuf = c_malloc(len + 1);
  if (newbuf == NULL) {
    return NULL;
  }

  strncpy(newbuf, path, len);
  newbuf[len] = '\0';

  return newbuf;
}