static char *rejfile = NULL;
 static LDAP    *ld = NULL;
 
-static int process_ldif_rec LDAP_P(( char *rbuf, int lineno ));
+static int process_ldif_rec LDAP_P(( char *rbuf, unsigned long lineno ));
 static int domodify LDAP_P((
        const struct berval *dn,
        LDAPMod **pmods,
        char            *matched_msg, *error_msg;
        int             rc, retval, ldifrc;
        int             len;
-       int             i = 0;
-       int             lineno, nextline = 0, lmax = 0;
+       int             i = 0, lmax = 0;
+       unsigned long   lineno, nextline = 0;
        LDAPControl     c[1];
 
        prog = lutil_progname( "ldapmodify", argc, argv );
 
 
 static int
-process_ldif_rec( char *rbuf, int linenum )
+process_ldif_rec( char *rbuf, unsigned long linenum )
 {
        LDIFRecord lr;
        int lrflags = ldapadd ? LDIF_DEFAULT_ADD : 0;
 
 LDAP_F( int )
 ldap_parse_ldif_record LDAP_P((
        struct berval *rbuf,
-       int linenum,
+       unsigned long linenum,
        LDIFRecord *lr,
        const char *errstr,
        unsigned int flags ));
 
 LDAP_F( int )
 ldap_parse_ldif_record_x LDAP_P((
        struct berval *rbuf,
-       int linenum,
+       unsigned long linenum,
        struct ldifrecord *lr,
        const char *errstr,
        unsigned int flags,
 
 LDAP_LDIF_F( int )
 ldif_read_record LDAP_P((
        LDIFFP *fp,
-       int *lineno,
+       unsigned long *lineno,
        char **bufp,
        int *buflen ));
 
 
 int
 ldif_read_record(
        LDIFFP      *lfp,
-       int         *lno,               /* ptr to line number counter              */
+       unsigned long *lno,             /* ptr to line number counter              */
        char        **bufp,     /* ptr to malloced output buffer           */
        int         *buflenp )  /* ptr to length of *bufp                  */
 {
 
 int
 ldap_parse_ldif_record_x(
        struct berval *rbuf,
-       int linenum,
+       unsigned long linenum,
        LDIFRecord *lr,
        const char *errstr,
        unsigned int flags,
                }
        
                if ( ( rc = ldif_parse_line2( line, lr->lr_btype+i, lr->lr_vals+i, &freev ) ) < 0 ) {
-                       fprintf( stderr, _("%s: invalid format (line %d) entry: \"%s\"\n"),
+                       fprintf( stderr, _("%s: invalid format (line %lu) entry: \"%s\"\n"),
                                errstr, linenum+i, dn == NULL ? "" : dn );
                        rc = LDAP_PARAM_ERROR;
                        goto leave;
                                if ( lr->lr_vals[i].bv_len != version1.bv_len || strncmp( lr->lr_vals[i].bv_val, version1.bv_val, version1.bv_len ) != 0 )
                                {
                                        fprintf( stderr,
-                                               _("%s: invalid version %s, line %d (ignored)\n"),
+                                               _("%s: invalid version %s, line %lu (ignored)\n"),
                                                errstr, lr->lr_vals[i].bv_val, linenum );
                                }
                                version++;
                        rc = parse_ldif_control( lr->lr_vals+i, &pctrls );
                        if (rc != 0) {
                                fprintf( stderr,
-                                                _("%s: Error processing %s line, line %d: %s\n"),
+                                                _("%s: Error processing %s line, line %lu: %s\n"),
                                                 errstr, BV_CONTROL.bv_val, linenum+i, ldap_err2string(rc) );
                        }
                }
                if ( i>= lr->lr_lines ) {
 short_input:
                        fprintf( stderr,
-                               _("%s: Expecting more input after %s line, line %d\n"),
+                               _("%s: Expecting more input after %s line, line %lu\n"),
                                errstr, lr->lr_btype[i-1].bv_val, linenum+i );
                        
                        rc = LDAP_PARAM_ERROR;
 
                if ( ++icnt != lr->lr_vals[i].bv_len ) {
                        fprintf( stderr, _("%s: illegal trailing space after"
-                               " \"%s: %s\" trimmed (line %d, entry \"%s\")\n"),
+                               " \"%s: %s\" trimmed (line %lu, entry \"%s\")\n"),
                                errstr, BV_CHANGETYPE.bv_val, lr->lr_vals[i].bv_val, linenum+i, dn );
                        lr->lr_vals[i].bv_val[icnt] = '\0';
                }
                if ( flags & LDIF_ENTRIES_ONLY ) {
                        if ( !( BV_CASEMATCH( lr->lr_vals+i, &BV_ADDCT )) ) {
                                ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
-                                                                       _("%s: skipping LDIF record beginning at line %d: "
+                                                                       _("%s: skipping LDIF record beginning at line %lu: "
                                                                          "changetype '%.*s' found but entries only was requested\n"),
                                                                        errstr, linenum,
                                                                        (int)lr->lr_vals[i].bv_len,
                                goto short_input;
                        if ( !BV_CASEMATCH( lr->lr_btype+i, &BV_NEWRDN )) {
                                fprintf( stderr, _("%s: expecting \"%s:\" but saw"
-                                       " \"%s:\" (line %d, entry \"%s\")\n"),
+                                       " \"%s:\" (line %lu, entry \"%s\")\n"),
                                        errstr, BV_NEWRDN.bv_val, lr->lr_btype[i].bv_val, linenum+i, dn );
                                rc = LDAP_PARAM_ERROR;
                                goto leave;
                                goto short_input;
                        if ( !BV_CASEMATCH( lr->lr_btype+i, &BV_DELETEOLDRDN )) {
                                fprintf( stderr, _("%s: expecting \"%s:\" but saw"
-                                       " \"%s:\" (line %d, entry \"%s\")\n"),
+                                       " \"%s:\" (line %lu, entry \"%s\")\n"),
                                        errstr, BV_DELETEOLDRDN.bv_val, lr->lr_btype[i].bv_val, linenum+i, dn );
                                rc = LDAP_PARAM_ERROR;
                                goto leave;
                        if ( i < lr->lr_lines ) {
                                if ( !BV_CASEMATCH( lr->lr_btype+i, &BV_NEWSUP )) {
                                        fprintf( stderr, _("%s: expecting \"%s:\" but saw"
-                                               " \"%s:\" (line %d, entry \"%s\")\n"),
+                                               " \"%s:\" (line %lu, entry \"%s\")\n"),
                                                errstr, BV_NEWSUP.bv_val, lr->lr_btype[i].bv_val, linenum+i, dn );
                                        rc = LDAP_PARAM_ERROR;
                                        goto leave;
                        got_all = delete_entry = 1;
                } else {
                        fprintf( stderr,
-                               _("%s:  unknown %s \"%s\" (line %d, entry \"%s\")\n"),
+                               _("%s:  unknown %s \"%s\" (line %lu, entry \"%s\")\n"),
                                errstr, BV_CHANGETYPE.bv_val, lr->lr_vals[i].bv_val, linenum+i, dn );
                        rc = LDAP_PARAM_ERROR;
                        goto leave;
                   there must be no changetype, and the flag LDIF_DEFAULT_ADD must be set */
                if ( flags & LDIF_ENTRIES_ONLY ) {
                        ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
-                                                               _("%s: skipping LDIF record beginning at line %d: "
+                                                               _("%s: skipping LDIF record beginning at line %lu: "
                                                                  "no changetype found but entries only was requested and "
                                                                  "the default setting for missing changetype is modify\n"),
                                                                errstr, linenum );
        if ( got_all ) {
                if ( i < lr->lr_lines ) {
                        fprintf( stderr,
-                               _("%s: extra lines at end (line %d, entry \"%s\")\n"),
+                               _("%s: extra lines at end (line %lu, entry \"%s\")\n"),
                                errstr, linenum+i, dn );
                        rc = LDAP_PARAM_ERROR;
                        goto leave;
                        for (j=i+1; j<lr->lr_lines; j++) {
                                if ( !lr->lr_btype[j].bv_val ) {
                                        fprintf( stderr,
-                                               _("%s: missing attributeDescription (line %d, entry \"%s\")\n"),
+                                               _("%s: missing attributeDescription (line %lu, entry \"%s\")\n"),
                                                errstr, linenum+j, dn );
                                        rc = LDAP_PARAM_ERROR;
                                        goto leave;
                        if ( BV_CASEMATCH( lr->lr_btype+i, &BV_DN )) {
                                fprintf( stderr, _("%s: attributeDescription \"%s\":"
                                        " (possible missing newline"
-                                               " after line %d, entry \"%s\"?)\n"),
+                                               " after line %lu, entry \"%s\"?)\n"),
                                        errstr, lr->lr_btype[i].bv_val, linenum+i - 1, dn );
                        }
                        if ( !BV_CASEMATCH( lr->lr_btype+i, &bv )) {
     
                        if ( ++icnt != lr->lr_vals[i].bv_len ) {
                                fprintf( stderr, _("%s: illegal trailing space after"
-                                       " \"%s: %s\" trimmed (line %d, entry \"%s\")\n"),
+                                       " \"%s: %s\" trimmed (line %lu, entry \"%s\")\n"),
                                        errstr, type, lr->lr_vals[i].bv_val, linenum+i, dn );
                                lr->lr_vals[i].bv_val[icnt] = '\0';
                        }
                                nmods--;
                        } else {        /* no modify op: invalid LDIF */
                                fprintf( stderr, _("%s: modify operation type is missing at"
-                                       " line %d, entry \"%s\"\n"),
+                                       " line %lu, entry \"%s\"\n"),
                                        errstr, linenum+i, dn );
                                rc = LDAP_PARAM_ERROR;
                                goto leave;
                } else {
                        if ( !BV_CASEMATCH( lr->lr_btype+i, &bv )) {
                                fprintf( stderr, _("%s: wrong attributeType at"
-                                       " line %d, entry \"%s\"\n"),
+                                       " line %lu, entry \"%s\"\n"),
                                        errstr, linenum+i, dn );
                                rc = LDAP_PARAM_ERROR;
                                goto leave;
 int
 ldap_parse_ldif_record(
        struct berval *rbuf,
-       int linenum,
+       unsigned long linenum,
        LDIFRecord *lr,
        const char *errstr,
        unsigned int flags )
 
 {
        backsql_info    *bi = (backsql_info *)be->be_private;
        LDIFFP          *fp;
-       int             rc = 0, lineno = 0, lmax = 0, ldifrc;
+       int             rc = 0, lmax = 0, ldifrc;
+       unsigned long   lineno = 0;
        char            *buf = NULL;
 
        assert( fname != NULL );
 
                if( e == NULL ) {
                        fprintf( stderr, "back-sql baseObject: "
-                                       "could not parse entry (line=%d)\n",
+                                       "could not parse entry (line=%lu)\n",
                                        lineno );
                        rc = LDAP_OTHER;
                        break;
                if ( !be_issuffix( be, &e->e_nname ) ) {
                        fprintf( stderr,
                                "back-sql: invalid baseObject - "
-                               "dn=\"%s\" (line=%d)\n",
+                               "dn=\"%s\" (line=%lu)\n",
                                e->e_name.bv_val, lineno );
                        entry_free( e );
                        rc = LDAP_OTHER;
 
 root_dse_read_file( const char *fname )
 {
        struct LDIFFP   *fp;
-       int rc = 0, lineno = 0, lmax = 0, ldifrc;
+       int rc = 0, lmax = 0, ldifrc;
+       unsigned long lineno = 0;
        char    *buf = NULL;
 
        if ( (fp = ldif_open( fname, "r" )) == NULL ) {
 
                if( e == NULL ) {
                        Debug( LDAP_DEBUG_ANY, "root_dse_read_file: "
-                               "could not parse entry (file=\"%s\" line=%d)\n",
+                               "could not parse entry (file=\"%s\" line=%lu)\n",
                                fname, lineno, 0 );
                        rc = LDAP_OTHER;
                        break;
                if( e->e_nname.bv_len ) {
                        Debug( LDAP_DEBUG_ANY,
                                "root_dse_read_file: invalid rootDSE "
-                               "- dn=\"%s\" (file=\"%s\" line=%d)\n",
+                               "- dn=\"%s\" (file=\"%s\" line=%lu)\n",
                                e->e_dn, fname, lineno );
                        entry_free( e );
                        rc = LDAP_OTHER;
 
 
 typedef struct Erec {
        Entry *e;
-       int lineno;
-       int nextline;
+       unsigned long lineno;
+       unsigned long nextline;
 } Erec;
 
 typedef struct Trec {
        Entry *e;
-       int lineno;
-       int nextline;
+       unsigned long lineno;
+       unsigned long nextline;
        int rc;
        int ready;
 } Trec;
                                         0);
 
                if( e == NULL ) {
-                       fprintf( stderr, "%s: could not parse entry (line=%d)\n",
+                       fprintf( stderr, "%s: could not parse entry (line=%lu)\n",
                                progname, erec->lineno );
                        return -2;
                }
                if( BER_BVISEMPTY( &e->e_nname ) &&
                        !BER_BVISEMPTY( be->be_nsuffix ))
                {
-                       fprintf( stderr, "%s: line %d: "
+                       fprintf( stderr, "%s: line %lu: "
                                "cannot add entry with empty dn=\"%s\"",
                                progname, erec->lineno, e->e_dn );
                        bd = select_backend( &e->e_nname, nosubordinates );
                /* check backend */
                bd = select_backend( &e->e_nname, nosubordinates );
                if ( bd != be ) {
-                       fprintf( stderr, "%s: line %d: "
+                       fprintf( stderr, "%s: line %lu: "
                                "database #%d (%s) not configured to hold \"%s\"",
                                progname, erec->lineno,
                                dbnum,
                        id = be->be_entry_put( be, erec.e, &bvtext );
                        if( id == NOID ) {
                                fprintf( stderr, "%s: could not add entry dn=\"%s\" "
-                                                                "(line=%d): %s\n", progname, erec.e->e_dn,
+                                                                "(line=%lu): %s\n", progname, erec.e->e_dn,
                                                                 erec.lineno, bvtext.bv_val );
                                rc = EXIT_FAILURE;
                                if( continuemode ) {
 
                        } break;
 
                case 'j':       /* jump to linenumber */
-                       if ( lutil_atoi( &jumpline, optarg ) ) {
+                       if ( lutil_atoul( &jumpline, optarg ) ) {
                                usage( tool, progname );
                        }
                        break;
 
        int tv_continuemode;
        int tv_nosubordinates;
        int tv_dryrun;
-       int tv_jumpline;
-       struct berval tv_sub_ndn;
        int tv_scope;
+       unsigned long tv_jumpline;
+       struct berval tv_sub_ndn;
        Filter *tv_filter;
        struct LDIFFP   *tv_ldiffp;
        struct berval tv_baseDN;
 
        OperationBuffer opbuf;
        Operation *op;
 
-       int checkvals;
-       int lineno, nextline, ldifrc;
+       int checkvals, ldifrc;
+       unsigned long lineno, nextline;
        int lmax;
        int rc = EXIT_SUCCESS;
 
                        "slapmodify", LDIF_NO_CONTROLS );
 
                if ( local_rc != LDAP_SUCCESS ) {
-                       fprintf( stderr, "%s: could not parse entry (line=%d)\n",
+                       fprintf( stderr, "%s: could not parse entry (line=%lu)\n",
                                progname, lineno );
                        rc = EXIT_FAILURE;
                        if( continuemode ) continue;
 
                case LDAP_REQ_MODRDN:
                case LDAP_REQ_DELETE:
-                       fprintf( stderr, "%s: request 0x%lx not supported (line=%d)\n",
+                       fprintf( stderr, "%s: request 0x%lx not supported (line=%lu)\n",
                                progname, (unsigned long)lr.lr_op, lineno );
                        rc = EXIT_FAILURE;
                        if( continuemode ) continue;
                        goto done;
 
                default:
-                       fprintf( stderr, "%s: unknown request 0x%lx (line=%d)\n",
+                       fprintf( stderr, "%s: unknown request 0x%lx (line=%lu)\n",
                                progname, (unsigned long)lr.lr_op, lineno );
                        rc = EXIT_FAILURE;
                        if( continuemode ) continue;
 
                local_rc = dnNormalize( 0, NULL, NULL, &lr.lr_dn, &ndn, NULL );
                if ( local_rc != LDAP_SUCCESS ) {
-                       fprintf( stderr, "%s: DN=\"%s\" normalization failed (line=%d)\n",
+                       fprintf( stderr, "%s: DN=\"%s\" normalization failed (line=%lu)\n",
                                progname, lr.lr_dn.bv_val, lineno );
                        rc = EXIT_FAILURE;
                        if( continuemode ) continue;
                if( BER_BVISEMPTY( &ndn ) &&
                        !BER_BVISEMPTY( be->be_nsuffix ))
                {
-                       fprintf( stderr, "%s: line %d: "
+                       fprintf( stderr, "%s: line %lu: "
                                "%s entry with empty dn=\"\"",
                                progname, lineno, request );
                        bd = select_backend( &ndn, nosubordinates );
                /* check backend */
                bd = select_backend( &ndn, nosubordinates );
                if ( bd != be ) {
-                       fprintf( stderr, "%s: line %d: "
+                       fprintf( stderr, "%s: line %lu: "
                                "database #%d (%s) not configured to hold \"%s\"",
                                progname, lineno,
                                dbnum,
 
                        local_rc = slap_str2ad( mod->mod_type, &mods.sm_desc, &text );
                        if ( local_rc != LDAP_SUCCESS ) {
-                               fprintf( stderr, "%s: slap_str2ad(\"%s\") failed for entry \"%s\" (%d: %s, lineno=%d)\n",
+                               fprintf( stderr, "%s: slap_str2ad(\"%s\") failed for entry \"%s\" (%d: %s, lineno=%lu)\n",
                                        progname, mod->mod_type, lr.lr_dn.bv_val, local_rc, text, lineno );
                                rc = EXIT_FAILURE;
                                mod_err = 1;
 
                        if( id == NOID ) {
                                fprintf( stderr, "%s: could not %s entry dn=\"%s\" "
-                                       "(line=%d): %s\n", progname, request, e->e_dn,
+                                       "(line=%lu): %s\n", progname, request, e->e_dn,
                                        lineno, bvtext.bv_val );
                                rc = EXIT_FAILURE;
                                entry_free( e );