← Back to branch summary

~ubuntu-branches/debian/jessie/netatalk/jessie

« back to all changes in this revision

Viewing changes to etc/afpd/fce_api.c

  • Committer: Package Import Robot
  • Author(s): Jonas Smedegaard
  • Date: 2012-03-20 23:37:08 UTC
  • mfrom: (1.1.12)
  • Revision ID: package-import@ubuntu.com-20120320233708-sp2k0av7f9sjnf4w
Tags: 2.2.2-1
http://bugs.debian.org/645290
http://bugs.debian.org/651406
* New upstream release.
* Drop patch cherry-picked upstream: Included in new upstream release.
* Build-depend on libldap2-dev and libacl1-dev, to enable LDAP support
  and support for extended ACLs (and possibly avoid FTBFS).
  Closes: bug#645290, #651406. Thanks to Peter Eisentraut and masc.
* Update copyright file:
  + Bump format to 1.0.
  + Fix double-indent in Copyright fields as per Policy §5.6.13.
  + Add Files paragraph for ACL code.
* Bump standards-version to 3.9.3.
* Update copyright file: Add disclaimer to License paragraph
  GAP~Makefile.in.
* Bump debhelper compat level to 7.
* Add patch 101 to start avahi-daemon (if available) before atalkd.
  Recommend avahi-daemon.

Show diffs side-by-side

added added

removed removed

Lines of Context:
etc/afpd/fce_api.c
155
155
    udp_initialized = FCE_FALSE;
156
156
}
157
157
 
158
 
 
159
158
/*
160
159
 * Construct a UDP packet for our listeners and return packet size
161
160
 * */
162
161
static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode, uint32_t event_id )
163
162
{
164
 
    size_t pathlen;
 
163
    size_t pathlen = 0;
165
164
    ssize_t data_len = 0;
 
165
    uint64_t *t;
166
166
 
167
 
    strncpy(packet->magic, FCE_PACKET_MAGIC, sizeof(packet->magic) );
 
167
    /* Set content of packet */
 
168
    memcpy(packet->magic, FCE_PACKET_MAGIC, sizeof(packet->magic) );
168
169
    packet->version = FCE_PACKET_VERSION;
169
170
    packet->mode = mode;
170
 
    packet->event_id = event_id;
171
 
 
172
 
    pathlen = strlen(path) + 1; /* include string terminator */
173
 
 
 
171
   
 
172
    packet->event_id = event_id; 
 
173
 
 
174
    pathlen = strlen(path); /* exclude string terminator */
 
175
    
174
176
    /* This should never happen, but before we bust this server, we send nonsense, fce listener has to cope */
175
177
    if (pathlen >= MAXPATHLEN)
176
178
        pathlen = MAXPATHLEN - 1;
177
179
 
178
 
    /* This is the payload len. Means: the stream has len bytes more until packet is finished */
179
 
    /* A server should read the first 16 byte, decode them and then fetch the rest */
 
180
    packet->datalen = pathlen;
 
181
 
 
182
    /* This is the payload len. Means: the packet has len bytes more until packet is finished */
180
183
    data_len = FCE_PACKET_HEADER_SIZE + pathlen;
181
 
    packet->datalen = pathlen;
182
184
 
183
185
    switch (mode) {
184
186
    case FCE_TM_SIZE:
185
 
        tm_used = hton64(tm_used);
186
 
        memcpy(packet->data, &tm_used, sizeof(tm_used));
187
 
        strncpy(packet->data + sizeof(tm_used), path, pathlen);
188
 
 
189
 
        packet->datalen += sizeof(tm_used);
 
187
        t = (uint64_t *)packet->data;
 
188
        *t = hton64(tm_used);
 
189
        memcpy(packet->data + sizeof(tm_used), path, pathlen);
 
190
        
 
191
        packet->datalen = pathlen + sizeof(tm_used);
190
192
        data_len += sizeof(tm_used);
191
193
        break;
192
194
    default:
193
 
        strncpy(packet->data, path, pathlen);
 
195
        memcpy(packet->data, path, pathlen);
194
196
        break;
195
197
    }
196
198
 
198
200
    return data_len;
199
201
}
200
202
 
201
 
static int pack_fce_packet(struct fce_packet *packet, unsigned char *buf)
 
203
/*
 
204
 * Handle Endianess and write into buffer w/o padding
 
205
 **/ 
 
206
static void pack_fce_packet(struct fce_packet *packet, unsigned char *buf, int maxlen)
202
207
{
203
208
    unsigned char *p = buf;
204
209
 
211
216
    *p = packet->mode;
212
217
    p++;
213
218
    
214
 
    uint32_t id = htonl(packet->event_id);
215
 
    memcpy(p, &id, sizeof(id));
 
219
    uint32_t *id = (uint32_t*)p;
 
220
    *id = htonl(packet->event_id);
216
221
    p += sizeof(packet->event_id);
217
222
 
218
 
    uint16_t l = htons(packet->datalen);
219
 
    memcpy(p, &l, sizeof(l));
220
 
    p += sizeof(l);
221
 
 
222
 
    memcpy(p, &packet->data[0], packet->datalen);
223
 
    p += packet->datalen;
224
 
 
225
 
    return 0;
 
223
    uint16_t *l = ( uint16_t *)p;
 
224
    *l = htons(packet->datalen);
 
225
    p += sizeof(packet->datalen);
 
226
 
 
227
    if (((p - buf) +  packet->datalen) < maxlen) {
 
228
        memcpy(p, &packet->data[0], packet->datalen);
 
229
    }
226
230
}
227
231
 
228
232
/*
250
254
 
251
255
    /* build our data packet */
252
256
    ssize_t data_len = build_fce_packet( &packet, path, mode, ++event_id );
253
 
    pack_fce_packet(&packet, iobuf);
 
257
    pack_fce_packet(&packet, iobuf, MAXIOBUF);
254
258
 
255
259
    for (int i = 0; i < udp_sockets; i++)
256
260
    {
281
285
 
282
286
            /* Okay, we have a running socket again, send server that we had a problem on our side*/
283
287
            data_len = build_fce_packet( &packet, "", FCE_CONN_BROKEN, 0 );
284
 
            pack_fce_packet(&packet, iobuf);
 
288
            pack_fce_packet(&packet, iobuf, MAXIOBUF);
285
289
 
286
290
            sendto(udp_entry->sock,
287
291
                   iobuf,
292
296
 
293
297
            /* Rebuild our original data packet */
294
298
            data_len = build_fce_packet( &packet, path, mode, event_id );
295
 
            pack_fce_packet(&packet, iobuf);
 
299
            pack_fce_packet(&packet, iobuf, MAXIOBUF);
296
300
        }
297
301
 
298
302
        sent_data = sendto(udp_entry->sock,
459
463
    if (!(fce_ev_enabled & (1 << FCE_FILE_DELETE)))
460
464
        return ret;
461
465
        
462
 
    ret = register_fce( path->u_name, FALSE, FCE_FILE_DELETE );
 
466
    ret = register_fce( path->u_name, false, FCE_FILE_DELETE );
463
467
 
464
468
    return ret;
465
469
}
473
477
    if (!(fce_ev_enabled & (1 << FCE_DIR_DELETE)))
474
478
        return ret;
475
479
        
476
 
    ret = register_fce( name, TRUE, FCE_DIR_DELETE);
 
480
    ret = register_fce( name, true, FCE_DIR_DELETE);
477
481
 
478
482
    return ret;
479
483
}
488
492
    if (!(fce_ev_enabled & (1 << FCE_DIR_CREATE)))
489
493
        return ret;
490
494
 
491
 
    ret = register_fce( path->u_name, TRUE, FCE_DIR_CREATE );
 
495
    ret = register_fce( path->u_name, true, FCE_DIR_CREATE );
492
496
 
493
497
    return ret;
494
498
}
504
508
    if (!(fce_ev_enabled & (1 << FCE_FILE_CREATE)))
505
509
        return ret;
506
510
 
507
 
    ret = register_fce( path->u_name, FALSE, FCE_FILE_CREATE );
 
511
    ret = register_fce( path->u_name, false, FCE_FILE_CREATE );
508
512
 
509
513
    return ret;
510
514
}
528
532
        return AFPERR_MISC;
529
533
    }
530
534
    
531
 
    ret = register_fce( u_name, FALSE, FCE_FILE_MODIFY );
 
535
    ret = register_fce( u_name, false, FCE_FILE_MODIFY );
532
536
    
533
537
    return ret;    
534
538
}
544
548
        return ret;
545
549
 
546
550
    tm_used = used;             /* oh what a hack */
547
 
    ret = register_fce(vol, FALSE, FCE_TM_SIZE);
 
551
    ret = register_fce(vol, false, FCE_TM_SIZE);
548
552
 
549
553
    return ret;
550
554
}
599
603
    }
600
604
 
601
605
    free(e);
 
606
 
 
607
    return AFP_OK;
602
608
}
603
609
 
604
610
#ifdef FCE_TEST_MAIN